qt5-legatus-legacy/Lts/Proxies/TrainingAreaBase/Plugins/AdlerJson/telegrams.cpp

#include "telegrams.h"

#include <QDebug>
#include <QJsonDocument>
#include <QString>
#include <ProjectDataManagement/pdm_translation.h>

namespace AdlerJson
{
// EX-Wirkfelddaten
void SAATELEGRAMS_EXPORT wirkfelddatenfromJson(const QJsonObject &data, Einheit &einheit, bool &bOk);

// EX-Erkundungsdaten
void SAATELEGRAMS_EXPORT erkundungsdatenFromJson(const QJsonObject &data, Erkundungsdaten &erkundungsdaten, bool &bOk);
void SAATELEGRAMS_EXPORT erkundungsdatenToJson(QJsonObject &data, const Erkundungsdaten &erkundungsdaten, bool &bOk);

// EX-Feuerkampfdaten
void SAATELEGRAMS_EXPORT feuerkampfdatenFromJson(const QJsonObject &data, Feuerkampfdaten &feuerkampfdaten, bool &bOk);
void SAATELEGRAMS_EXPORT feuerkampfdatenToJson(QJsonObject &data, const Feuerkampfdaten &feuerkampfdaten, bool &bOk);

// EX-Zielmeldedaten
void SAATELEGRAMS_EXPORT zielmeldedatenFromJson(const QJsonObject &data, Zielmeldedaten &zielmeldedaten, bool &bOk);
void SAATELEGRAMS_EXPORT zielmeldedatenToJson(QJsonObject &data, const Zielmeldedaten &zielmeldedaten);

// EX-Feuerstellungsdaten
void SAATELEGRAMS_EXPORT feuerstellungsdatenFromJson(const QJsonObject &data, Feuerstellungsdaten &feuerstellungsdaten, bool &bOk);
void SAATELEGRAMS_EXPORT feuerstellungsdatenToJson(QJsonObject &data, const Feuerstellungsdaten &feuerstellungsdaten, bool &bOk);

// EX-Waffensystemdaten
void SAATELEGRAMS_EXPORT waffensystemdatenFromJson(const QJsonObject &data, Waffensystemdaten &waffensystemdaten, bool &bOk);
void SAATELEGRAMS_EXPORT waffensystemdatenToJson(QJsonObject &data, const Waffensystemdaten &waffensystemdaten);

// EX-Ladeplatzdaten
void SAATELEGRAMS_EXPORT ladeplatzdatenFromJson(const QJsonObject &data, Ladeplatzdaten &ladeplatzdaten, bool &bOk);
void SAATELEGRAMS_EXPORT ladeplatzdatenToJson(QJsonObject &data, const Ladeplatzdaten &ladeplatzdaten);

// EX-Stellungswechseldaten
void SAATELEGRAMS_EXPORT stellungswechseldatenFromJson(const QJsonObject &data, Stellungswechseldaten &stellungswechseldaten, bool &bOk);
void SAATELEGRAMS_EXPORT stellungswechseldatenToJson(QJsonObject &data, const Stellungswechseldaten &stellungswechseldaten);

// EX-Koordinierungsdaten - defined in header
// void SAATELEGRAMS_EXPORT koordinierungsdatenFromJson(const QJsonObject &data, Koordinierungsdaten& koordinierungsdaten, bool& bOk);
// void SAATELEGRAMS_EXPORT koordinierungsdatenToJson( QJsonObject &data, const Koordinierungsdaten& koordinierungsdaten);

// EX-L3 Einheit
void SAATELEGRAMS_EXPORT einheitfromJson(const QJsonObject &data, Einheit &einheit, bool &bOk);
void SAATELEGRAMS_EXPORT einheitToJson(QJsonObject &data, const Einheit &einheit);
// EX-L8 Geschosse
void SAATELEGRAMS_EXPORT geschossfromJson(const QJsonObject &data, Geschoss &geschosse, bool &bOk);
void SAATELEGRAMS_EXPORT geschossToJson(QJsonObject &data, const Geschoss &geschosse);

// EX-L12 Zieldaten
void SAATELEGRAMS_EXPORT zieldatenfromJson(const QJsonObject &data, Zieldaten &zieldaten, bool &bOk);
void SAATELEGRAMS_EXPORT zieldatenToJson(QJsonObject &data, const Zieldaten &zieldaten);

// EX-L13 Geographische Koordinate
void SAATELEGRAMS_EXPORT koordinatefromJson(const QJsonObject &data, Koordinate &koordinate, bool &bOk);
void SAATELEGRAMS_EXPORT koordinateToJson(QJsonObject &data, const Koordinate &koordinate);
// EX-L14
void SAATELEGRAMS_EXPORT koordinateMitHoeheFromJson(const QJsonObject &data, KoordinateMitHoehe &koordinateMitHoehe, bool &bOk);

// EX-L15
void SAATELEGRAMS_EXPORT zeitangabe_DTGFromJson(const QJsonObject &data, Zeitangabe_DTG &zeitangabe_DTG, bool &bOk);
void SAATELEGRAMS_EXPORT zeitangabe_DTGToJson(QJsonObject &data, const Zeitangabe_DTG &zeitangabe_DTG);

// EX-L18 Wirkungsbereich
void SAATELEGRAMS_EXPORT wirkungsbereichFromJson(const QJsonObject &data, Wirkungsbereich &wirkungsbereich, bool &bOk);
void SAATELEGRAMS_EXPORT wirkungsbereichToJson(QJsonObject &data, const Wirkungsbereich &wirkungsbereich);

// EX-L29 Erkundungseinheit
void SAATELEGRAMS_EXPORT erkundungseinheitFromJson(const QJsonObject &data, Erkundungseinheit &erkundungseinheit, bool &bOk);
void SAATELEGRAMS_EXPORT erkundungseinheitToJson(QJsonObject &data, const Erkundungseinheit &erkundungseinheit);

// EX-L30 Erkundungsstellungen
void SAATELEGRAMS_EXPORT erkundungsstellungenFromJson(const QJsonObject &data, Erkundungsstellungen &erkundungsstellungen, bool &bOk);
// EX-L33 Feuerkommando
void SAATELEGRAMS_EXPORT feuerkommandoFromJson(const QJsonObject &data, Feuerkommando &feuerkommando, bool &bOk);
void SAATELEGRAMS_EXPORT feuerkommandoToJson(QJsonObject &data, const Feuerkommando &feuerkommando);
void SAATELEGRAMS_EXPORT feuerkommandosToJson(QJsonArray &data, const QVector<Feuerkommando> &feuerkommandos);

// EX-L34 Wirkmittel Feuerkommando
void SAATELEGRAMS_EXPORT wirkmittelFeuerkommandoFromJson(const QJsonObject &data, WirkmittelFeuerkommando &wirkmittelFeuerkommando, bool &bOk);
void wirkmittelFeuerkommansdoToJson(QJsonArray &data, const QVector<WirkmittelFeuerkommando> &wirkmittelFeuerkommando);
void SAATELEGRAMS_EXPORT wirkmittelFeuerkommandoToJson(QJsonObject &data, const WirkmittelFeuerkommando &wirkmittelFeuerkommando);
// EX-L35 Flugbahnpunkt
void SAATELEGRAMS_EXPORT flugbahnpunktFromJson(const QJsonObject &data, Flugbahnpunkt &flugbahnpunkt, bool &bOk);
void SAATELEGRAMS_EXPORT flugbahnpunktToJson(QJsonObject &data, const Flugbahnpunkt &flugbahnpunkt);
//  Array [EX-L35 Flugbahnpunkte]
void SAATELEGRAMS_EXPORT flugbahnpunkteFromJson(const QJsonArray &data, QVector<Flugbahnpunkt> &flugbahnpunkte, bool &bOk);
void SAATELEGRAMS_EXPORT flugbahnpunkteToJson(QJsonArray &data, const QVector<Flugbahnpunkt> &flugbahnpunkte);

// EX-L36 Feuerkommando Geschosse
void SAATELEGRAMS_EXPORT feuerkommandoGeschosseFromJson(const QJsonObject &data, FeuerkommandoGeschosse &feuerkommandoGeschosse, bool &bOk);
void SAATELEGRAMS_EXPORT feuerkommandoGeschosseToJson(QJsonObject &data, const FeuerkommandoGeschosse &feuerkommandoGeschosse);

// EX-L37 Flugbahnberechnung Geschosse
void SAATELEGRAMS_EXPORT FlugbahnberechnungGeschosseFromJson(const QJsonObject &data, FlugbahnberechnungGeschosse &flugbahnberechnungGeschosse, bool &bOk);
void SAATELEGRAMS_EXPORT FlugbahnberechnungGeschosseToJson(QJsonObject &data, const FlugbahnberechnungGeschosse &flugbahnberechnungGeschosse);

// EX-L39 Streuungsdaten
void SAATELEGRAMS_EXPORT streuungsdatenFromJson(const QJsonObject &data, Streuungsdaten &streuungsdaten, bool &bOk);
void SAATELEGRAMS_EXPORT streuungsdatenToJson(QJsonObject &data, const Streuungsdaten &streuungsdaten);

// EX-L45 Anmeldebestaetigung Fehlercode
void SAATELEGRAMS_EXPORT anBestaetigungsdatenFromJson(const QJsonObject &data, AnBestaetigungsdaten &anBestaetigungsdaten, bool &bOk);
void SAATELEGRAMS_EXPORT anBestaetigungsdatenToJson(QJsonObject &data, const AnBestaetigungsdaten &anBestaetigungsdaten);

// EX-L49 Wirkmittel Feuerkommando Rakete - defined in header
// void SAATELEGRAMS_EXPORT wirkmittelFeuerkommandoRaketeToJson(QJsonObject &data, const WirkmittelFeuerkommandoRakete &wirkmittelFeuerkommandoRakete);
// void SAATELEGRAMS_EXPORT wirkmittelFeuerkommandoRaketeFromJson(const QJsonObject &data, WirkmittelFeuerkommandoRakete &wirkmittelFeuerkommandoRakete, bool &bOk);

// EX-FQ(BA-BB-FK) Wirkfeldplanung
void SAATELEGRAMS_EXPORT wirkfeldplanungDataFromJson(const QJsonObject &data, WirkfeldplanungData &wirkfeldplanungData, bool &bOk);

void SAATELEGRAMS_EXPORT koordinateMitHoeheToJson(QJsonObject &data, const KoordinateMitHoehe &koordinateMitHoehe);
void SAATELEGRAMS_EXPORT erkundungsstellungenToJson(QJsonObject &data, const Erkundungsstellungen &erkundungsstellungen);

// EX-FH Feuer HALT
void SAATELEGRAMS_EXPORT feuerHaltDatenFromJson(const QJsonObject &data, FeuerHaltDaten &feuerHaltDaten, bool &bOk);
void SAATELEGRAMS_EXPORT feuerHaltDatenToJson(QJsonObject &data, const FeuerHaltDaten &feuerHaltDaten);

// 7.1.17 EX-HQ(G) Fuehrungslinien und Grenzen - defined in header
// void SAATELEGRAMS_EXPORT fuehrungsdatenFromJson(const QJsonObject &data, Fuehrungsdaten& fuehrungsdaten, bool& bOk);
// void SAATELEGRAMS_EXPORT fuehrungsdatenToJson( QJsonObject &data, const Fuehrungsdaten& fuehrungsdaten);

// 7.2.22 EX-Flugbahnberechnung
void SAATELEGRAMS_EXPORT exFlugbahnberechnungDatenFromJson(const QJsonObject &data, FlugBerechnungsDaten &flugBerechnungsDaten, bool &bOk);
void SAATELEGRAMS_EXPORT exFlugbahnberechnungDatenToJson(QJsonObject &data, const FlugBerechnungsDaten &flugBerechnungsDaten);

// 7.2.23 EX-Flugbahndaten
void SAATELEGRAMS_EXPORT flugbahndatenFromJson(const QJsonObject &data, Flugbahndaten &flugbahndaten, bool &bOk);
void SAATELEGRAMS_EXPORT flugbahndatenToJson(QJsonObject &data, const Flugbahndaten &flugbahndaten);

// 7.1.23 EX-AQ Freitextmeldung
// void SAATELEGRAMS_EXPORT freitextdatenFromJson(const QJsonObject &data, FreitextDaten& freitextDaten, bool& bOk);
// void SAATELEGRAMS_EXPORT freitextdatenToJson( QJsonObject &data, const FreitextDaten& freitextDaten, bool& bOk);

//
// Helper functions
//
static inline double toDouble(const QJsonValue &val, bool &bOk)
{
  bOk = bOk && val.isDouble();
  return val.toDouble();
}

static inline int toInteger(const QJsonValue &val, bool &bOk)
{
  bOk = bOk && val.isDouble();
  return qRound(val.toDouble());
}

// static inline int64_t toInt64(const QJsonValue &val, bool &bOk)
// {
//   bOk = bOk && val.isDouble();
//   return qRound64(val.toDouble());
// }

// static inline bool toBoolean(const QJsonValue &val, bool &bOk)
// {
//   bOk = bOk && val.isBool();
//   return val.toBool();
// }

template <typename T> QJsonObject SAATelegram::toJsonInternal() { return QJsonObject(); }
template <> QJsonObject SAATelegram::toJsonInternal<SAATelegram>() { return QJsonObject(); }
template <> QJsonObject EXTelegramBase::toJsonInternal<EXTelegramBase>()
{
  QJsonObject obj = static_cast<SAATelegram *>(this)->toJsonInternal<SAATelegram>();
  obj[JsonKeys::TYPE()] = typeName;
  obj[JsonKeys::TYPE_ID()] = typeId;
  obj[JsonKeys::UUID_()] = uuid;
  obj[JsonKeys::VERSION()] = version;
  obj[JsonKeys::SENDER()] = sender;
  obj[JsonKeys::RECEIVER()] = receiver;
  obj[JsonKeys::REFERENCE_UUID()] = referenceUuid;
  obj[JsonKeys::TIMESTAMP()] = timestamp;
  return obj;
}

template <> QJsonObject EXRegistration::toJsonInternal<EXRegistration>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  data[JsonKeys::PARTY_ID()] = partyId;
  data[JsonKeys::ADLER_VERBUND()] = adlerVerbund;
  data[JsonKeys::SZENAR()] = szenar;

  obj[JsonKeys::DATA()] = data;
  return obj;
}

// template<>
// QJsonObject EXRegistrationConfirmation::toJsonInternal<EXRegistrationConfirmation>()
// {
//   QJsonObject obj = static_cast<EXTelegramBase*>(this)->toJsonInternal<EXTelegramBase>();
//   if(!Afe.isEmpty())
//     obj[JsonKeys::AFE()] = Afe;
//   return obj;
// }

template <> QJsonObject EXConnectionTestReply::toJsonInternal<EXConnectionTestReply>() { return static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>(); }
QJsonObject EXTelegramBase::toJson() { return toJsonInternal<EXTelegramBase>(); }
QJsonObject EXRegistration::toJson() { return toJsonInternal<EXRegistration>(); }
// QJsonObject EXRegistrationConfirmation::toJson()
// {
//   return toJsonInternal<EXRegistrationConfirmation>();
// }

QJsonObject ExAnmeldebestaetigung::toJson()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  data[JsonKeys::ERRORTEXT()] = AnmeldebestaetigungFehlercodeMap.key(anBestaetigungsdaten.error);
  obj[JsonKeys::DATA()] = data;
  return obj;
}

QJsonObject EXDeregistration::toJson() { return toJsonInternal<EXDeregistration>(); }
template <> QJsonObject EXDeregistration::toJsonInternal<EXDeregistration>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  data[JsonKeys::PARTY_ID()] = partyId;
  obj[JsonKeys::DATA()] = data;
  return obj;
}

QJsonObject EXConnectionTestRequest::toJson() { return toJsonInternal<EXConnectionTestRequest>(); }

template <typename T> QJsonObject EXConnectionTestRequest::toJsonInternal()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  // QJsonObject data;
  // obj[JsonKeys::DATA()] = data;
  return obj;
}

QJsonObject EXConnectionTestReply::toJson() { return toJsonInternal<EXConnectionTestReply>(); }

QJsonObject EXStatus::toJson() { return toJsonInternal<EXStatus>(); }
template <> QJsonObject EXStatus::toJsonInternal<EXStatus>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();
  QJsonObject data;

  data[JsonKeys::STATUS()] = szenarstatusMap.key(status);
  obj[JsonKeys::DATA()] = data;
  return obj;
}
// ======================================================================================================
// fachliche Meldungen

// ======================================================================================================

// ======================================================================================================
// Gruppen:

// Strukturen und Legenden

// EX-Wirkfelddaten
void SAATELEGRAMS_EXPORT wirkfelddatenFromJson(const QJsonObject &data, Wirkfelddaten &wirkfelddaten, bool &bOk)
{
  wirkfelddaten.feuerkampfReferenz = data[JsonKeys::FEUERKAMPFREFERENZ()].toString();
  zieldatenfromJson(data[JsonKeys::ZIELDATEN()].toObject(), wirkfelddaten.zieldaten, bOk);
  wirkfelddaten.abfeuerungsArt = AbfeuerungsartMap.value(data[JsonKeys::ABFEUERUNGSART()].toString());
  wirkfelddaten.forderung = ForderungMap.value(data[JsonKeys::FORDERUNG()].toString());
  wirkfelddaten.dauer = toInteger(data[JsonKeys::DAUER()], bOk);
  feuerkommandoFromJson(data[JsonKeys::FEUERKOMMANDO()].toObject(), wirkfelddaten.feuerkommando, bOk);
}

// EX-Feuerkampfdaten
void SAATELEGRAMS_EXPORT feuerkampfdatenFromJson(const QJsonObject &data, Feuerkampfdaten &feuerkampfdaten, bool &bOk)
{
  bOk = true;
  bOk &= data.contains(JsonKeys::FEUERKAMPFREFERENZ());
  bOk &= data.contains(JsonKeys::VEREIN());
  bOk &= data.contains(JsonKeys::KENNER());

  if (!bOk)
    return;

  feuerkampfdaten.feuerkampfReferenz = data[JsonKeys::FEUERKAMPFREFERENZ()].toString();
  feuerkampfdaten.verein = data[JsonKeys::VEREIN()].toString();                              // EX-L2
  feuerkampfdaten.kenner = waffensystemkennerMap.value(data[JsonKeys::KENNER()].toString()); // EX-L27
}
void SAATELEGRAMS_EXPORT feuerkampfdatenToJson(QJsonObject &data, const Feuerkampfdaten &feuerkampfdaten)
{
  data[JsonKeys::FEUERKAMPFREFERENZ()] = feuerkampfdaten.feuerkampfReferenz;
  data[JsonKeys::VEREIN()] = feuerkampfdaten.verein;
  data[JsonKeys::KENNER()] = waffensystemkennerMap.key(feuerkampfdaten.kenner);
}

// EX-Erkundungsdaten
void SAATELEGRAMS_EXPORT erkundungsdatenFromJson(const QJsonObject &data, Erkundungsdaten &erkundungsdaten, bool &bOk)
{
  bOk = true;
  bOk &= data.contains(JsonKeys::FEUERKOMMANDO());
  bOk &= data.contains(JsonKeys::KOORDINATE());
  bOk &= data.contains(JsonKeys::STELLUNGEN());

  if (!bOk)
    return;

  erkundungseinheitFromJson(data[JsonKeys::FEUERKOMMANDO()].toObject(), erkundungsdaten.einheit, bOk);
  koordinateMitHoeheFromJson(data[JsonKeys::KOORDINATE()].toObject(), erkundungsdaten.ladeplatz, bOk);
  erkundungsstellungenFromJson(data[JsonKeys::STELLUNGEN()].toObject(), erkundungsdaten.stellungen, bOk);
}

void SAATELEGRAMS_EXPORT erkundungsdatenToJson(QJsonObject &data, const Erkundungsdaten &erkundungsdaten)
{
  QJsonObject erkundungseinheit;
  erkundungseinheitToJson(erkundungseinheit, erkundungsdaten.einheit);
  data[JsonKeys::FEUERKOMMANDO()] = erkundungseinheit;
  QJsonObject koordinate;
  koordinateMitHoeheToJson(koordinate, erkundungsdaten.ladeplatz);
  data[JsonKeys::KOORDINATE()] = koordinate;
  QJsonObject erkundungsstellungen;
  erkundungsstellungenToJson(erkundungsstellungen, erkundungsdaten.stellungen);
  data[JsonKeys::STELLUNGEN()] = erkundungsstellungen;
}

// EX-Zielmeldedaten
void SAATELEGRAMS_EXPORT zielmeldedatenFromJson(const QJsonObject &data, Zielmeldedaten &zielmeldedaten, bool &bOk)
{
  zieldatenfromJson(data[JsonKeys::ZIELDATEN()].toObject(), zielmeldedaten.zieldaten, bOk);             // EX-L12
  zielmeldedaten.abfeuerungsArt = AbfeuerungsartMap.value(data[JsonKeys::ABFEUERUNGSART()].toString()); // EX-L6
  zielmeldedaten.forderung = ForderungMap.value(data[JsonKeys::FORDERUNG()].toString());
  zielmeldedaten.dauer = toInteger(data[JsonKeys::DAUER()], bOk);
  QJsonArray FeuerkommandoArray = data[JsonKeys::FEUERKOMMANDO()].toArray();
  for (const QJsonValue &value : qAsConst(FeuerkommandoArray))
  {
    Feuerkommando feuerkommando;
    feuerkommandoFromJson(value.toObject(), feuerkommando, bOk); // EX-L34 Wirkmittel Feuerkommando
    zielmeldedaten.feuerkommandos.append(feuerkommando);
  }
}

void SAATELEGRAMS_EXPORT zielmeldedatenToJson(QJsonObject &data, const Zielmeldedaten &zielmeldedaten)
{
  QJsonObject objZieldaten;
  zieldatenToJson(objZieldaten, zielmeldedaten.zieldaten);
  data[JsonKeys::ZIELDATEN()] = objZieldaten;
  data[JsonKeys::ABFEUERUNGSART()] = AbfeuerungsartMap.key(zielmeldedaten.abfeuerungsArt);
  data[JsonKeys::FORDERUNG()] = ForderungMap.key(zielmeldedaten.forderung);
  data[JsonKeys::DAUER()] = zielmeldedaten.dauer;

  QJsonArray objFeuerkommandos;
  feuerkommandosToJson(objFeuerkommandos, zielmeldedaten.feuerkommandos);
  data[JsonKeys::FEUERKOMMANDO()] = objFeuerkommandos;
}

// EX-Feuerstellungsdaten
void SAATELEGRAMS_EXPORT feuerstellungsdatenFromJson(const QJsonObject &data, Feuerstellungsdaten &feuerstellungsdaten, bool &bOk)
{
  feuerstellungsdaten.typ = waffensystemtypMap.value(data[JsonKeys::TYP()].toString());                       // EX-L26
  feuerstellungsdaten.status = StatusL28Map.value(data[JsonKeys::STATUS()].toString());                       // EX-L28
  einheitfromJson(data[JsonKeys::FEUEREINHEIT()].toObject(), feuerstellungsdaten.feuereinheit, bOk);          // EX-L3
  koordinateMitHoeheFromJson(data[JsonKeys::MITTELPUNKT()].toObject(), feuerstellungsdaten.mittelpunkt, bOk); // EX-L3
  QJsonArray koordinatenArray = data[JsonKeys::KOORDINATEN()].toArray();
  for (const QJsonValue &value : qAsConst(koordinatenArray))
  {
    KoordinateMitHoehe koordinate;
    koordinateMitHoeheFromJson(value.toObject(), koordinate, bOk); // EX-L34 Wirkmittel Feuerkommando
    feuerstellungsdaten.koordinaten.append(koordinate);
  }

  QJsonArray geschosseArray = data[JsonKeys::GESCHOSSE()].toArray();
  for (const QJsonValue &value : qAsConst(geschosseArray))
  {
    Geschoss geschosse;
    geschossfromJson(value.toObject(), geschosse, bOk); // EX-L34 Wirkmittel Feuerkommando
    feuerstellungsdaten.geschosse.append(geschosse);
  }
  bool optional = true;
  wirkungsbereichFromJson(data[JsonKeys::WIRKUNGSBEREICH()].toObject(), feuerstellungsdaten.wirkungsbereich, optional); // EX-L18
}

void SAATELEGRAMS_EXPORT feuerstellungsdatenToJson(QJsonObject &data, const Feuerstellungsdaten &feuerstellungsdaten)
{
  data[JsonKeys::TYP()] = waffensystemtypMap.key(feuerstellungsdaten.typ);
  data[JsonKeys::STATUS()] = StatusL28Map.key(feuerstellungsdaten.status);
  QJsonObject einheit;
  einheitToJson(einheit, feuerstellungsdaten.feuereinheit);
  data[JsonKeys::FEUEREINHEIT()] = einheit;

  // mittelpunkt
  QJsonObject mittelpunkt;
  koordinateMitHoeheToJson(mittelpunkt, feuerstellungsdaten.mittelpunkt);
  data[JsonKeys::MITTELPUNKT()] = mittelpunkt;

  QJsonArray koordinaten;
  for (const auto &koordinate : qAsConst(feuerstellungsdaten.koordinaten))
  {
    QJsonObject koordinateObj;
    koordinateMitHoeheToJson(koordinateObj, koordinate);
    koordinaten.append(koordinateObj);
  }
  data[JsonKeys::KOORDINATEN()] = koordinaten;

  QJsonArray geschosse;
  for (const auto &geschoss : qAsConst(feuerstellungsdaten.geschosse))
  {
    QJsonObject geschossObj;
    geschossToJson(geschossObj, geschoss);
    geschosse.append(geschossObj);
  }
  data[JsonKeys::GESCHOSSE()] = geschosse;

  QJsonObject objWirkungsbereich;
  wirkungsbereichToJson(objWirkungsbereich, feuerstellungsdaten.wirkungsbereich);
  data[JsonKeys::WIRKUNGSBEREICH()] = objWirkungsbereich;
}

// EX-Waffensystemdaten
void SAATELEGRAMS_EXPORT waffensystemdatenFromJson(const QJsonObject &data, Waffensystemdaten &waffensystemdaten, bool &bOk)
{
  waffensystemdaten.typ = waffensystemtypMap.value(data[JsonKeys::TYP()].toString());          // EX-L26
  waffensystemdaten.kenner = waffensystemkennerMap.value(data[JsonKeys::KENNER()].toString()); // EX-L27
  waffensystemdaten.status = StatusL28Map.value(data[JsonKeys::STATUS()].toString());          // EX-L28
  einheitfromJson(data[JsonKeys::EINHEIT()].toObject(), waffensystemdaten.einheit, bOk);       // EX-L3

  QJsonArray geschosseArray = data[JsonKeys::GESCHOSSE()].toArray();
  for (const QJsonValue &value : qAsConst(geschosseArray))
  {
    Geschoss geschosse;
    geschossfromJson(value.toObject(), geschosse, bOk); // EX-L34 Wirkmittel Feuerkommando
    waffensystemdaten.geschosse.append(geschosse);
  }
  koordinateMitHoeheFromJson(data[JsonKeys::KOORDINATE()].toObject(), waffensystemdaten.koordinate, bOk);        // EX-L14
  wirkungsbereichFromJson(data[JsonKeys::WIRKUNGSBEREICH()].toObject(), waffensystemdaten.wirkungsbereich, bOk); // EX-L18
}

void SAATELEGRAMS_EXPORT waffensystemdatenToJson(QJsonObject &data, const Waffensystemdaten &waffensystemdaten)
{
  data[JsonKeys::TYP()] = waffensystemtypMap.key(waffensystemdaten.typ);
  data[JsonKeys::KENNER()] = waffensystemkennerMap.key(waffensystemdaten.kenner);
  data[JsonKeys::STATUS()] = StatusL28Map.key(waffensystemdaten.status);
  QJsonObject einheit;
  einheitToJson(einheit, waffensystemdaten.einheit);
  data[JsonKeys::EINHEIT()] = einheit;

  QJsonArray geschosse;
  for (const auto &geschoss : qAsConst(waffensystemdaten.geschosse))
  {
    QJsonObject geschossObj;
    geschossToJson(geschossObj, geschoss);
    geschosse.append(geschossObj);
  }
  data[JsonKeys::GESCHOSSE()] = geschosse;

  QJsonObject koordinateObj;
  koordinateMitHoeheToJson(koordinateObj, waffensystemdaten.koordinate);
  data[JsonKeys::KOORDINATE()] = koordinateObj;

  QJsonObject wirkungsbereichObj;
  wirkungsbereichToJson(wirkungsbereichObj, waffensystemdaten.wirkungsbereich);
  data[JsonKeys::WIRKUNGSBEREICH()] = wirkungsbereichObj;
}

// EX-Ladeplatzdaten
void SAATELEGRAMS_EXPORT ladeplatzdatenFromJson(const QJsonObject &data, Ladeplatzdaten &ladeplatzdaten, bool &bOk)
{
  einheitfromJson(data[JsonKeys::EINHEIT()].toObject(), ladeplatzdaten.einheit, bOk); // EX-L3

  koordinateMitHoeheFromJson(data[JsonKeys::KOORDINATE()].toObject(), ladeplatzdaten.koordinate, bOk);
  QJsonArray geschosseArray = data[JsonKeys::GESCHOSSE()].toArray();
  for (const QJsonValue &value : qAsConst(geschosseArray))
  {
    Geschoss geschosse;
    geschossfromJson(value.toObject(), geschosse, bOk); // EX-L34 Wirkmittel Feuerkommando
    ladeplatzdaten.geschosse.append(geschosse);
  }
}

void SAATELEGRAMS_EXPORT ladeplatzdatenToJson(QJsonObject &data, const Ladeplatzdaten &ladeplatzdaten)
{
  QJsonObject einheit;
  einheitToJson(einheit, ladeplatzdaten.einheit);
  data[JsonKeys::EINHEIT()] = einheit;

  QJsonArray geschosse;
  for (const auto &geschoss : qAsConst(ladeplatzdaten.geschosse))
  {
    QJsonObject geschossObj;
    geschossToJson(geschossObj, geschoss);
    geschosse.append(geschossObj);
  }
  data[JsonKeys::GESCHOSSE()] = geschosse;

  QJsonObject koordinateObj;
  koordinateMitHoeheToJson(koordinateObj, ladeplatzdaten.koordinate);
  data[JsonKeys::KOORDINATE()] = koordinateObj;
}

// EX-Stellungswechseldaten
void SAATELEGRAMS_EXPORT stellungswechseldatenFromJson(const QJsonObject &data, Stellungswechseldaten &stellungswechseldaten, bool &bOk)
{
  stellungswechseldaten.verein = data[JsonKeys::VEREIN()].toString();
  stellungswechseldaten.r = toInteger(data[JsonKeys::R()], bOk);
  stellungswechseldaten.oi = ortsIdMap.value(data[JsonKeys::OI()].toString());
}

void SAATELEGRAMS_EXPORT stellungswechseldatenToJson(QJsonObject &data, const Stellungswechseldaten &stellungswechseldaten)
{
  data[JsonKeys::VEREIN()] = stellungswechseldaten.verein;
  data[JsonKeys::R()] = stellungswechseldaten.r;
  data[JsonKeys::OI()] = ortsIdMap.key(stellungswechseldaten.oi);
}

// EX-Munitionsdaten
void SAATELEGRAMS_EXPORT munitionsdatenFromJson(const QJsonObject &data, Munitionsdaten &munitionsdaten, bool &bOk)
{
  bOk = true;
  munitionsdaten.verein = data[JsonKeys::VEREIN()].toString();
}

// EX-LpMunitionsdaten
void SAATELEGRAMS_EXPORT lpMunitionsdatenFromJson(const QJsonObject &data, LpMunitionsdaten &LpMunitionsdaten, bool &bOk)
{
  einheitfromJson(data[JsonKeys::EINHEIT()].toObject(), LpMunitionsdaten.einheit, bOk); // EX-L3
}

// EX-Koordinierungsdaten
void SAATELEGRAMS_EXPORT koordinierungsdatenFromJson(const QJsonObject &data, Koordinierungsdaten &koordinierungsdaten, bool &bOk)
{
  koordinierungsdaten.art = art_L25Map.value(data[JsonKeys::ART()].toString()); // EX-L26
  koordinierungsdaten.name = data[JsonKeys::NAME()].toString();
  koordinierungsdaten.meldungsnummer = data[JsonKeys::MELDUNGSNUMMER()].toInt();
  koordinierungsdaten.truppenteil = data[JsonKeys::TRUPPENTEIL()].toString();
  zeitangabe_DTGFromJson(data[JsonKeys::AB()].toObject(), koordinierungsdaten.ab, bOk);   // EX-L15
  zeitangabe_DTGFromJson(data[JsonKeys::BIS()].toObject(), koordinierungsdaten.bis, bOk); // EX-L15

  QJsonArray koordinatenArray = data[JsonKeys::KOORDINATEN()].toArray();
  for (const QJsonValue &value : qAsConst(koordinatenArray))
  {
    Koordinate koordinate;
    koordinatefromJson(value.toObject(), koordinate, bOk); // EX-L13
    koordinierungsdaten.koordinaten.append(koordinate);
  }

  koordinatefromJson(data[JsonKeys::MITTELPUNKT()].toObject(), koordinierungsdaten.mittelpunkt, bOk); // EX-L15
  koordinierungsdaten.radius = toInteger(data[JsonKeys::RADIUS()], bOk);
  koordinierungsdaten.maxGipfel = toInteger(data[JsonKeys::MAXGIPFEL()], bOk);
}

void SAATELEGRAMS_EXPORT koordinierungsdatenToJson(QJsonObject &data, const Koordinierungsdaten &koordinierungsdaten)
{
  data[JsonKeys::ART()] = art_L25Map.key(koordinierungsdaten.art);
  data[JsonKeys::NAME()] = koordinierungsdaten.name;
  data[JsonKeys::MELDUNGSNUMMER()] = koordinierungsdaten.meldungsnummer;
  data[JsonKeys::TRUPPENTEIL()] = koordinierungsdaten.truppenteil;
  QJsonObject objTimestamp;
  zeitangabe_DTGToJson(objTimestamp, koordinierungsdaten.ab);
  data[JsonKeys::AB()] = objTimestamp;
  zeitangabe_DTGToJson(objTimestamp, koordinierungsdaten.bis);
  data[JsonKeys::BIS()] = objTimestamp;

  QJsonArray koordinatenArray;
  for (const auto &koordinate : qAsConst(koordinierungsdaten.koordinaten))
  {
    QJsonObject objKoordinate;
    koordinateToJson(objKoordinate, koordinate);
    koordinatenArray.append(objKoordinate);
  }
  data[JsonKeys::KOORDINATEN()] = koordinatenArray;

  // mittelpunkt
  QJsonObject mittelpunkt;
  koordinateToJson(mittelpunkt, koordinierungsdaten.mittelpunkt);
  data[JsonKeys::MITTELPUNKT()] = mittelpunkt;
  data[JsonKeys::RADIUS()] = koordinierungsdaten.radius;
  data[JsonKeys::MAXGIPFEL()] = koordinierungsdaten.maxGipfel;
}

// EX-L3 Einheit
void SAATELEGRAMS_EXPORT einheitfromJson(const QJsonObject &data, Einheit &einheit, bool &bOk)
{
  bOk = true;
  bOk &= data.contains(JsonKeys::VEREIN());
  bOk &= data.contains(JsonKeys::R());
  bOk &= data.contains(JsonKeys::OI());

  if (!bOk)
    return;

  einheit.verein = data[JsonKeys::VEREIN()].toString();
  einheit.r = toInteger(data[JsonKeys::R()], bOk);
  einheit.oi = ortsIdMap.value(data[JsonKeys::OI()].toString());
}

void SAATELEGRAMS_EXPORT einheitToJson(QJsonObject &data, const Einheit &einheit)
{
  data[JsonKeys::VEREIN()] = einheit.verein;
  data[JsonKeys::R()] = einheit.r;
  data[JsonKeys::OI()] = ortsIdMap.key(einheit.oi);
}

// EX-L8 Geschosse
void SAATELEGRAMS_EXPORT geschossfromJson(const QJsonObject &data, Geschoss &geschosse, bool &bOk)
{
  bOk = true;
  bOk &= data.contains(JsonKeys::GESCHOSSSORTE());
  bOk &= data.contains(JsonKeys::LADUNG());
  bOk &= data.contains(JsonKeys::ZUENDER());
  bOk &= data.contains(JsonKeys::ANZAHL());

  if (!bOk)
    return;

  geschosse.geschosssorte = data[JsonKeys::GESCHOSSSORTE()].toString();
  geschosse.ladung = data[JsonKeys::LADUNG()].toString();
  geschosse.zuender = data[JsonKeys::ZUENDER()].toString();
  geschosse.anzahl = toInteger(data[JsonKeys::ANZAHL()], bOk);
}
void SAATELEGRAMS_EXPORT geschossToJson(QJsonObject &data, const Geschoss &geschosse)
{
  data[JsonKeys::GESCHOSSSORTE()] = geschosse.geschosssorte;
  data[JsonKeys::LADUNG()] = geschosse.ladung;
  data[JsonKeys::ZUENDER()] = geschosse.zuender;
  data[JsonKeys::ANZAHL()] = geschosse.anzahl;
}

// EX-L13 Geographische Koordinate
void SAATELEGRAMS_EXPORT koordinatefromJson(const QJsonObject &data, Koordinate &koordinate, bool &bOk)
{
  bOk = true;
  bOk &= data.contains(JsonKeys::LATITUDE());
  bOk &= data.contains(JsonKeys::LONGITUDE());

  if (!bOk)
    return;

  koordinate.latitude = toDouble(data[JsonKeys::LATITUDE()], bOk);
  koordinate.longitude = toDouble(data[JsonKeys::LONGITUDE()], bOk);
}

void SAATELEGRAMS_EXPORT koordinateToJson(QJsonObject &data, const Koordinate &koordinate)
{
  data[JsonKeys::LATITUDE()] = koordinate.latitude;
  data[JsonKeys::LONGITUDE()] = koordinate.longitude;
}

// EX-L14
void SAATELEGRAMS_EXPORT koordinateMitHoeheFromJson(const QJsonObject &data, KoordinateMitHoehe &koordinateMitHoehe, bool &bOk)
{
  bOk = true;
  bOk &= data.contains(JsonKeys::KOORDINATE());
  bOk &= data.contains(JsonKeys::HOEHE());

  if (!bOk)
    return;

  koordinatefromJson(data[JsonKeys::KOORDINATE()].toObject(), koordinateMitHoehe.koordinate, bOk);
  koordinateMitHoehe.hoehe = toInteger(data[JsonKeys::HOEHE()], bOk);
}

void SAATELEGRAMS_EXPORT koordinateMitHoeheToJson(QJsonObject &data, const KoordinateMitHoehe &koordinateMitHoehe)
{
  data[JsonKeys::HOEHE()] = koordinateMitHoehe.hoehe;
  QJsonObject koordinate;
  koordinateToJson(koordinate, koordinateMitHoehe.koordinate);
  data[JsonKeys::KOORDINATE()] = koordinate;
}

void SAATELEGRAMS_EXPORT zeitangabe_DTGFromJson(const QJsonObject &data, Zeitangabe_DTG &zeitangabe_DTG, bool &bOk)
{
  zeitangabe_DTG.stunden = toInteger(data[JsonKeys::STUNDEN()], bOk);
  zeitangabe_DTG.minuten = toInteger(data[JsonKeys::MINUTEN()], bOk);
  zeitangabe_DTG.sekunden = toInteger(data[JsonKeys::SEKUNDEN()], bOk);
  zeitangabe_DTG.tag = toInteger(data[JsonKeys::TAG()], bOk);
  zeitangabe_DTG.monat = toInteger(data[JsonKeys::MONAT()], bOk);
  zeitangabe_DTG.jahr = toInteger(data[JsonKeys::JAHR()], bOk);

  zeitangabe_DTG.ZVz = data[JsonKeys::ZVZ()].toString();
  zeitangabe_DTG.ZDS = data[JsonKeys::ZDS()].toString();
  zeitangabe_DTG.ZDM = data[JsonKeys::ZDM()].toString();
}

void SAATELEGRAMS_EXPORT zeitangabe_DTGToJson(QJsonObject &data, const Zeitangabe_DTG &zeitangabe_DTG)
{
  data[JsonKeys::JAHR()] = zeitangabe_DTG.jahr;
  data[JsonKeys::MONAT()] = zeitangabe_DTG.monat;
  data[JsonKeys::TAG()] = zeitangabe_DTG.tag;
  data[JsonKeys::STUNDEN()] = zeitangabe_DTG.stunden;
  data[JsonKeys::MINUTEN()] = zeitangabe_DTG.minuten;
  data[JsonKeys::SEKUNDEN()] = zeitangabe_DTG.sekunden;
  data[JsonKeys::ZDM()] = zeitangabe_DTG.ZDM;
  data[JsonKeys::ZDS()] = zeitangabe_DTG.ZDS;
  data[JsonKeys::ZVZ()] = zeitangabe_DTG.ZVz;
}

// EX-L12 Zieldaten
void SAATELEGRAMS_EXPORT zieldatenfromJson(const QJsonObject &data, Zieldaten &zieldaten, bool &bOk)
{
  bOk = true;
  bOk &= data.contains(JsonKeys::NUMMER());
  bOk &= data.contains(JsonKeys::GEOMETRIE());
  bOk &= data.contains(JsonKeys::KOORDINATE());
  bOk &= data.contains(JsonKeys::RELATIV_KOORDINATE());
  bOk &= data.contains(JsonKeys::BREITE_RADIUS());
  bOk &= data.contains(JsonKeys::TIEFE());
  bOk &= data.contains(JsonKeys::ZIELACHSE());
  bOk &= data.contains(JsonKeys::ELEMENTE());
  bOk &= data.contains(JsonKeys::TYP());
  bOk &= data.contains(JsonKeys::SUB_TYP());

  if (!bOk)
    return;

  zieldaten.nummer = toInteger(data[JsonKeys::NUMMER()], bOk);
  const QString artStr = data[JsonKeys::GEOMETRIE()].toString();
  zieldaten.geometrie = zielgeometrieMap.value(artStr);

  KoordinateMitHoehe koordinateMitHoehe;
  koordinateMitHoeheFromJson(data[JsonKeys::KOORDINATE()].toObject(), koordinateMitHoehe, bOk);
  zieldaten.koordinate = koordinateMitHoehe;
  koordinateMitHoeheFromJson(data[JsonKeys::RELATIV_KOORDINATE()].toObject(), koordinateMitHoehe, bOk);
  zieldaten.relativKoordinate = koordinateMitHoehe;
  if (data.contains(JsonKeys::BREITE_RADIUS()))
    zieldaten.breiteRadius = toInteger(data[JsonKeys::BREITE_RADIUS()], bOk);
  else
    zieldaten.breiteRadius = 0;
  if (data.contains(JsonKeys::TIEFE()))
    zieldaten.tiefe = toInteger(data[JsonKeys::TIEFE()], bOk);
  else
    zieldaten.tiefe = 0;
  zieldaten.zielachse = toInteger(data[JsonKeys::ZIELACHSE()], bOk);
  zieldaten.zog = toInteger(data[JsonKeys::ZOG()], bOk);
  zieldaten.elemente = toInteger(data[JsonKeys::ELEMENTE()], bOk);
  zieldaten.typ = data[JsonKeys::TYP()].toString();
  zieldaten.subTyp = data[JsonKeys::SUB_TYP()].toString();
}
// EX-L12 Zieldaten
void SAATELEGRAMS_EXPORT zieldatenToJson(QJsonObject &data, const Zieldaten &zieldaten)
{
  data[JsonKeys::NUMMER()] = zieldaten.nummer;
  data[JsonKeys::GEOMETRIE()] = zielgeometrieMap.key(zieldaten.geometrie);

  QJsonObject koordData;
  koordinateMitHoeheToJson(koordData, zieldaten.koordinate); // toSJon;
  data[JsonKeys::KOORDINATE()] = koordData;

  QJsonObject koordDataRel;
  koordinateMitHoeheToJson(koordDataRel, zieldaten.relativKoordinate);
  data[JsonKeys::RELATIV_KOORDINATE()] = koordDataRel;

  data[JsonKeys::BREITE_RADIUS()] = zieldaten.breiteRadius;
  data[JsonKeys::TIEFE()] = zieldaten.tiefe;
  data[JsonKeys::ZIELACHSE()] = zieldaten.zielachse;
  data[JsonKeys::ZOG()] = zieldaten.zog;
  data[JsonKeys::ELEMENTE()] = zieldaten.elemente;
  data[JsonKeys::TYP()] = zieldaten.typ;
  data[JsonKeys::SUB_TYP()] = zieldaten.subTyp;
  QString message = QString::fromUtf8(QJsonDocument(data).toJson());
}

// EX-L18 Wirkungsbereich
void SAATELEGRAMS_EXPORT wirkungsbereichFromJson(const QJsonObject &data, Wirkungsbereich &wirkungsbereich, bool &bOk)
{
  bOk = true;
  wirkungsbereich.grundrichtung = toInteger(data[JsonKeys::GRUNDRICHTUNG()], bOk);
  if (!bOk)
    return;
  wirkungsbereich.links = toInteger(data[JsonKeys::LINKS()], bOk);
  if (!bOk)
    return;
  wirkungsbereich.rechts = toInteger(data[JsonKeys::RECHTS()], bOk);
  if (!bOk)
    return;
}

void SAATELEGRAMS_EXPORT wirkungsbereichToJson(QJsonObject &data, const Wirkungsbereich &wirkungsbereich)
{
  data[JsonKeys::GRUNDRICHTUNG()] = wirkungsbereich.grundrichtung;
  data[JsonKeys::LINKS()] = wirkungsbereich.links;
  data[JsonKeys::RECHTS()] = wirkungsbereich.rechts;
}

// EX-L29 Erkundungseinheit
void SAATELEGRAMS_EXPORT erkundungseinheitFromJson(const QJsonObject &data, Erkundungseinheit &erkundungseinheit, bool &bOk)
{
  // QString verein;
  // int r;
  bOk = true;
  bOk &= data.contains(JsonKeys::VEREIN());
  bOk &= data.contains(JsonKeys::EINHEIT());

  if (!bOk)
    return;

  erkundungseinheit.verein = data[JsonKeys::VEREIN()].toString(); // EX-L2
  erkundungseinheit.r = toInteger(data[JsonKeys::EINHEIT()], bOk);
}

void SAATELEGRAMS_EXPORT erkundungseinheitToJson(QJsonObject &data, const Erkundungseinheit &erkundungseinheit)
{
  data[JsonKeys::VEREIN()] = erkundungseinheit.verein;
  data[JsonKeys::EINHEIT()] = erkundungseinheit.r;
}

// EX-L30 Erkundungsstellungen
void SAATELEGRAMS_EXPORT erkundungsstellungenFromJson(const QJsonObject &data, Erkundungsstellungen &erkundungsstellungen, bool &bOk)
{
  bOk = true;
  bOk &= data.contains(JsonKeys::WAFFENPLAETZE());
  bOk &= data.contains(JsonKeys::WIRKUNGSBEREICH());

  if (!bOk)
    return;

  // KoordinateMitHoehe waffenplaetze; //  EX-L14
  // Wirkungsbereich wirkungsbereich; // EX-L18

  QJsonArray waffenplaetzeArray = data[JsonKeys::WAFFENPLAETZE()].toArray();
  for (const QJsonValue &value : qAsConst(waffenplaetzeArray))
  {
    KoordinateMitHoehe koordinateMitHoehe;
    koordinateMitHoeheFromJson(value.toObject(), koordinateMitHoehe, bOk);
    erkundungsstellungen.waffenplaetze.append(koordinateMitHoehe);
  }
  wirkungsbereichFromJson(data[JsonKeys::WIRKUNGSBEREICH()].toObject(), erkundungsstellungen.wirkungsbereich, bOk); // EX-L18
}

void SAATELEGRAMS_EXPORT erkundungsstellungenToJson(QJsonObject &data, const Erkundungsstellungen &erkundungsstellungen)
{
  QJsonArray objWaffenplatzList;
  for (const auto waffenplatz : qAsConst(erkundungsstellungen.waffenplaetze))
  {
    QJsonObject objWaffenplatz;
    koordinateMitHoeheToJson(objWaffenplatz, waffenplatz);
    objWaffenplatzList.append(objWaffenplatz);
  }
  data[JsonKeys::WAFFENPLAETZE()] = objWaffenplatzList;

  QJsonDocument jsonDoc(data);

  QJsonObject objWirkungsbereich;
  wirkungsbereichToJson(objWirkungsbereich, erkundungsstellungen.wirkungsbereich);
  data[JsonKeys::WIRKUNGSBEREICH()] = objWirkungsbereich;
}

// EX-L33 Feuerkommando
void SAATELEGRAMS_EXPORT feuerkommandoFromJson(const QJsonObject &data, Feuerkommando &feuerkommando, bool &bOk)
{
  feuerkommando.verein = data[JsonKeys::VEREIN()].toString();
  feuerkommando.typ = waffensystemtypMap.value(data[JsonKeys::TYP()].toString()); // EX-L26

  if (data[JsonKeys::WIRKMITTEL()].isNull() || !data.contains(JsonKeys::WIRKMITTEL()))
    ;
  else
  {
    QJsonArray wirkmittelArray = data[JsonKeys::WIRKMITTEL()].toArray();
    for (const QJsonValue &value : qAsConst(wirkmittelArray))
    {
      WirkmittelFeuerkommando wirkmittel;
      wirkmittelFeuerkommandoFromJson(value.toObject(), wirkmittel, bOk); // EX-L34 Wirkmittel Feuerkommando
      feuerkommando.wirkmittel.append(wirkmittel);
    }
  }
  if (data[JsonKeys::WIRKMITTELRAKETE()].isNull() || !data.contains(JsonKeys::WIRKMITTELRAKETE()))
    return;
  else
  {
    QJsonArray wirkmittelArray = data[JsonKeys::WIRKMITTELRAKETE()].toArray();
    for (const QJsonValue &value : qAsConst(wirkmittelArray))
    {
      WirkmittelFeuerkommandoRakete wirkmittel;
      wirkmittelFeuerkommandoRaketeFromJson(value.toObject(), wirkmittel, bOk); // EX-L34 Wirkmittel Feuerkommando
      feuerkommando.wirkmittelRakete.append(wirkmittel);
    }
  }
}

void SAATELEGRAMS_EXPORT feuerkommandosToJson(QJsonArray &data, const QVector<Feuerkommando> &feuerkommandos)
{
  for (const auto &feuerkommando : qAsConst(feuerkommandos))
  {
    QJsonObject objFeuerkommand;
    feuerkommandoToJson(objFeuerkommand, feuerkommando);
    data.append(objFeuerkommand);
  }
}

void SAATELEGRAMS_EXPORT feuerkommandoToJson(QJsonObject &data, const Feuerkommando &feuerkommando)
{
  data[JsonKeys::VEREIN()] = feuerkommando.verein;
  data[JsonKeys::TYP()] = waffensystemtypMap.key(feuerkommando.typ);
  QJsonArray objWirkmittelList;
  QJsonArray objWirkmittelRaketeList;
  for (const auto &kommando : qAsConst(feuerkommando.wirkmittel))
  {
    QJsonObject objWirkmittel;
    wirkmittelFeuerkommandoToJson(objWirkmittel, kommando);
    objWirkmittelList.append(objWirkmittel);
  }
  data[JsonKeys::WIRKMITTEL()] = objWirkmittelList;

  for (const auto &kommando : qAsConst(feuerkommando.wirkmittelRakete))
  {
    QJsonObject objWirkmittel;
    wirkmittelFeuerkommandoRaketeToJson(objWirkmittel, kommando);
    objWirkmittelRaketeList.append(objWirkmittel);
  }
  data[JsonKeys::WIRKMITTEL()] = objWirkmittelList;
  data[JsonKeys::WIRKMITTELRAKETE()] = objWirkmittelRaketeList;
}
// EX-L34 Wirkmittel Feuerkommando
void wirkmittelFeuerkommandoFromJson(const QJsonObject &data, WirkmittelFeuerkommando &wirkmittelFeuerkommando, bool &bOk)
{
  bOk = true;
  bOk &= data.contains(JsonKeys::KENNER());
  bOk &= data.contains(JsonKeys::AUFTREFFPUNKT());
  bOk &= data.contains(JsonKeys::FLUGZEIT());
  bOk &= data.contains(JsonKeys::GIPFELHOEHE());
  bOk &= data.contains(JsonKeys::SCHUSSRICHTUNG());
  bOk &= data.contains(JsonKeys::GESCHOSS());
  bOk &= data.contains(JsonKeys::FLUGBAHNPUNKT());
  bOk &= data.contains(JsonKeys::STREUUNG());

  if (!bOk)
    return;

  wirkmittelFeuerkommando.kenner = waffensystemkennerMap.value(data[JsonKeys::KENNER()].toString());                  // EX-L27
  koordinateMitHoeheFromJson(data[JsonKeys::AUFTREFFPUNKT()].toObject(), wirkmittelFeuerkommando.auftreffpunkt, bOk); // EX-L14
  wirkmittelFeuerkommando.flugzeit = toDouble(data[JsonKeys::FLUGZEIT()], bOk);
  wirkmittelFeuerkommando.gipfelhoehe = toInteger(data[JsonKeys::GIPFELHOEHE()], bOk);
  wirkmittelFeuerkommando.schussrichtung = toDouble(data[JsonKeys::SCHUSSRICHTUNG()], bOk);
  feuerkommandoGeschosseFromJson(data[JsonKeys::GESCHOSS()].toObject(), wirkmittelFeuerkommando.geschoss, bOk);  // EX-L36
  flugbahnpunkteFromJson(data[JsonKeys::FLUGBAHNPUNKT()].toArray(), wirkmittelFeuerkommando.flugbahnpunkt, bOk); // EX-L35
  streuungsdatenFromJson(data[JsonKeys::STREUUNG()].toObject(), wirkmittelFeuerkommando.streuung, bOk);          // EX-L39
}

void wirkmittelFeuerkommandosToJson(QJsonArray &data, const QVector<WirkmittelFeuerkommando> &wirkmittelFeuerkommando)
{
  for (const auto &feuerkommando : qAsConst(wirkmittelFeuerkommando))
  {
    QJsonObject fkd;
    wirkmittelFeuerkommandoToJson(fkd, feuerkommando);
    data.append(fkd);
  }
}

void wirkmittelFeuerkommansdoToJson(QJsonArray &data, const QVector<WirkmittelFeuerkommando> &wirkmittelFeuerkommando)
{
  for (const auto &wfk : qAsConst(wirkmittelFeuerkommando))
  {
    QJsonObject obj;
    wirkmittelFeuerkommandoToJson(obj, wfk);
    data.append(obj);
  }
}

void wirkmittelFeuerkommandoToJson(QJsonObject &data, const WirkmittelFeuerkommando &wirkmittelFeuerkommando)
{
  data[JsonKeys::KENNER()] = waffensystemkennerMap.key(wirkmittelFeuerkommando.kenner);
  QJsonObject koordinate;
  koordinateMitHoeheToJson(koordinate, wirkmittelFeuerkommando.auftreffpunkt);
  data[JsonKeys::AUFTREFFPUNKT()] = koordinate;

  data[JsonKeys::FLUGZEIT()] = wirkmittelFeuerkommando.flugzeit;
  data[JsonKeys::GIPFELHOEHE()] = wirkmittelFeuerkommando.gipfelhoehe;
  data[JsonKeys::SCHUSSRICHTUNG()] = wirkmittelFeuerkommando.schussrichtung;
  QJsonObject geschoss;
  feuerkommandoGeschosseToJson(geschoss, wirkmittelFeuerkommando.geschoss);
  data[JsonKeys::GESCHOSS()] = geschoss;

  QJsonArray flugPunkte;
  flugbahnpunkteToJson(flugPunkte, wirkmittelFeuerkommando.flugbahnpunkt);
  data[JsonKeys::FLUGBAHNPUNKT()] = flugPunkte;

  QJsonObject streuung;
  streuungsdatenToJson(streuung, wirkmittelFeuerkommando.streuung);
  data[JsonKeys::STREUUNG()] = streuung;
}

// EX-L35 Flugbahnpunkt
void SAATELEGRAMS_EXPORT flugbahnpunktFromJson(const QJsonObject &data, Flugbahnpunkt &flugbahnpunkt, bool &bOk)
{
  bOk = true;
  bOk &= data.contains(JsonKeys::ZEIT());
  bOk &= data.contains(JsonKeys::X_RELATIV());
  bOk &= data.contains(JsonKeys::Y_RELATIV());
  bOk &= data.contains(JsonKeys::Z_RELATIV());

  if (!bOk)
    return;

  flugbahnpunkt.zeit = toDouble(data[JsonKeys::ZEIT()], bOk);
  flugbahnpunkt.xRelativ = toDouble(data[JsonKeys::X_RELATIV()], bOk);
  flugbahnpunkt.yRelativ = toDouble(data[JsonKeys::Y_RELATIV()], bOk);
  flugbahnpunkt.zRelativ = toDouble(data[JsonKeys::Z_RELATIV()], bOk);
}

void SAATELEGRAMS_EXPORT flugbahnpunktToJson(QJsonObject &data, const Flugbahnpunkt &flugbahnpunkt)
{
  data[JsonKeys::ZEIT()] = flugbahnpunkt.zeit;
  data[JsonKeys::X_RELATIV()] = flugbahnpunkt.xRelativ;
  data[JsonKeys::Y_RELATIV()] = flugbahnpunkt.yRelativ;
  data[JsonKeys::Z_RELATIV()] = flugbahnpunkt.zRelativ;
}

//  Array [EX-L35 Flugbahnpunkte]
void SAATELEGRAMS_EXPORT flugbahnpunkteFromJson(const QJsonArray &data, QVector<Flugbahnpunkt> &flugbahnpunkte, bool &bOk)
{
  for (const QJsonValue &value : qAsConst(data))
  {
    QJsonObject obj = value.toObject();
    Flugbahnpunkt flugbahnpunkt;
    flugbahnpunktFromJson(obj, flugbahnpunkt, bOk);
    flugbahnpunkte.append(flugbahnpunkt);
  }
}

void SAATELEGRAMS_EXPORT flugbahnpunkteToJson(QJsonArray &data, const QVector<Flugbahnpunkt> &flugbahnpunkte)
{
  if (flugbahnpunkte.isEmpty())
    return;

  for (const auto &flugpunkt : qAsConst(flugbahnpunkte))
  {
    QJsonObject objFlugpunkt;
    flugbahnpunktToJson(objFlugpunkt, flugpunkt);
    data.append(objFlugpunkt);
  }
}

// EX-L36 Feuerkommando Geschosse
void SAATELEGRAMS_EXPORT feuerkommandoGeschosseFromJson(const QJsonObject &data, FeuerkommandoGeschosse &feuerkommandoGeschosse, bool &bOk)
{
  bOk = true;
  bOk &= data.contains(JsonKeys::GESCHOSSSORTE());
  bOk &= data.contains(JsonKeys::ZUENDER());
  bOk &= data.contains(JsonKeys::ZUENDERFUNKTION());
  bOk &= data.contains(JsonKeys::ZUENDER_ZEIT());
  bOk &= data.contains(JsonKeys::ANZAHL());
  bOk &= data.contains(JsonKeys::INTERVALL());

  if (!bOk)
    return;

  feuerkommandoGeschosse.geschosssorte = data[JsonKeys::GESCHOSSSORTE()].toString(); // EX-L9
  feuerkommandoGeschosse.ladung = data[JsonKeys::LADUNG()].toString();               // EX-L10
  feuerkommandoGeschosse.ladungsNummer = data[JsonKeys::LADUNGSNUMMER()].toInt();
  feuerkommandoGeschosse.zuender = data[JsonKeys::ZUENDER()].toString();                 // EX-L11
  feuerkommandoGeschosse.zuenderFunktion = data[JsonKeys::ZUENDERFUNKTION()].toString(); // EX-L41
  feuerkommandoGeschosse.zuenderZeit = toDouble(data[JsonKeys::ZUENDER_ZEIT()], bOk);    // [ms]
  feuerkommandoGeschosse.anzahl = toInteger(data[JsonKeys::ANZAHL()], bOk);
  feuerkommandoGeschosse.intervall = toInteger(data[JsonKeys::INTERVALL()], bOk);
}
void SAATELEGRAMS_EXPORT feuerkommandoGeschosseToJson(QJsonObject &data, const FeuerkommandoGeschosse &feuerkommandoGeschosse)
{
  data[JsonKeys::GESCHOSSSORTE()] = feuerkommandoGeschosse.geschosssorte;
  data[JsonKeys::LADUNG()] = feuerkommandoGeschosse.ladung;
  data[JsonKeys::LADUNGSNUMMER()] = feuerkommandoGeschosse.ladungsNummer;
  data[JsonKeys::ZUENDER()] = feuerkommandoGeschosse.zuender;
  data[JsonKeys::ZUENDERFUNKTION()] = feuerkommandoGeschosse.zuenderFunktion;
  data[JsonKeys::ZUENDER_ZEIT()] = feuerkommandoGeschosse.zuenderZeit;
  data[JsonKeys::ANZAHL()] = feuerkommandoGeschosse.anzahl;
  data[JsonKeys::INTERVALL()] = feuerkommandoGeschosse.intervall;
}

// EX-L37 Flugbahnberechnung Geschosse
void SAATELEGRAMS_EXPORT flugbahnberechnungGeschosseFromJson(const QJsonObject &data, FlugbahnberechnungGeschosse &flugbahnberechnungGeschosse, bool &bOk)
{
  bOk &= data.contains(JsonKeys::GESCHOSSSORTE());
  bOk &= data.contains(JsonKeys::ZUENDER());
  bOk &= data.contains(JsonKeys::ZUENDERFUNKTION());

  if (!bOk)
    return;

  flugbahnberechnungGeschosse.geschosssorte = data[JsonKeys::GESCHOSSSORTE()].toString();     // EX-L9
  flugbahnberechnungGeschosse.ladung = data[JsonKeys::LADUNG()].toString();                   // EX-L10
  flugbahnberechnungGeschosse.zuender = data[JsonKeys::ZUENDER()].toString();                 // EX-L11
  flugbahnberechnungGeschosse.zuenderFunktion = data[JsonKeys::ZUENDERFUNKTION()].toString(); // EX-L41
}

void SAATELEGRAMS_EXPORT FlugbahnberechnungGeschosseToJson(QJsonObject &data, const FlugbahnberechnungGeschosse &flugbahnberechnungGeschosse)
{
  data[JsonKeys::GESCHOSSSORTE()] = flugbahnberechnungGeschosse.geschosssorte;
  data[JsonKeys::LADUNG()] = flugbahnberechnungGeschosse.ladung;
  data[JsonKeys::ZUENDER()] = flugbahnberechnungGeschosse.zuender;
  data[JsonKeys::ZUENDERFUNKTION()] = flugbahnberechnungGeschosse.zuenderFunktion;
}

// EX-L38 Flugbahndaten Geschosse
void SAATELEGRAMS_EXPORT FlugbahndatenGeschosseFromJson(const QJsonObject &data, FlugbahndatenGeschosse &flugbahndatenGeschosse, bool &bOk)
{
  flugbahndatenGeschosse.geschosssorte = data[JsonKeys::GESCHOSSSORTE()].toString(); // EX-L9
  flugbahndatenGeschosse.ladung = data[JsonKeys::LADUNG()].toString();
  flugbahndatenGeschosse.ladungsNummer = toInteger(data[JsonKeys::LADUNGSNUMMER()], bOk);
  flugbahndatenGeschosse.zuender = data[JsonKeys::ZUENDER()].toString(); // EX-L9
  flugbahndatenGeschosse.zuenderFunktion = data[JsonKeys::ZUENDERFUNKTION()].toString();
  if (data[JsonKeys::ZUENDER_ZEIT()].isNull() || !data.contains(JsonKeys::ZUENDER_ZEIT()))
  {
    flugbahndatenGeschosse.zuenderZeit = -1.0;
  }
  else
  {
    flugbahndatenGeschosse.zuenderZeit = toDouble(data[JsonKeys::ZUENDER_ZEIT()], bOk);
  }
}

void SAATELEGRAMS_EXPORT FlugbahndatenGeschosseToJson(QJsonObject &data, const FlugbahndatenGeschosse &flugbahndatenGeschosse)
{
  data[JsonKeys::GESCHOSSSORTE()] = flugbahndatenGeschosse.geschosssorte;
  data[JsonKeys::LADUNG()] = flugbahndatenGeschosse.ladung;
  data[JsonKeys::LADUNGSNUMMER()] = flugbahndatenGeschosse.ladungsNummer;
  data[JsonKeys::ZUENDER()] = flugbahndatenGeschosse.zuender;
  data[JsonKeys::ZUENDERFUNKTION()] = flugbahndatenGeschosse.zuenderFunktion;
  data[JsonKeys::ZUENDER_ZEIT()] = flugbahndatenGeschosse.zuenderZeit;
}

// EX-L39 Streuungsdaten
void streuungsdatenFromJson(const QJsonObject &data, Streuungsdaten &streuungsdaten, bool &bOk)
{
  bOk = true;
  bOk &= data.contains(JsonKeys::LAENGS_STREUUNG());
  bOk &= data.contains(JsonKeys::SEITEN_STREUUNG());
  bOk &= data.contains(JsonKeys::LAENGS_STREUUNG_H());
  bOk &= data.contains(JsonKeys::SEITEN_STREUUNG_H());

  if (!bOk)
    return;

  streuungsdaten.laengsstreuung = toDouble(data[JsonKeys::LAENGS_STREUUNG()], bOk);
  streuungsdaten.seitenstreuung = toDouble(data[JsonKeys::SEITEN_STREUUNG()], bOk);
  streuungsdaten.laengsstreuungH = toDouble(data[JsonKeys::LAENGS_STREUUNG_H()], bOk);
  streuungsdaten.seitenstreuungH = toDouble(data[JsonKeys::SEITEN_STREUUNG_H()], bOk);
};

void SAATELEGRAMS_EXPORT streuungsdatenToJson(QJsonObject &data, const Streuungsdaten &streuungsdaten)
{
  data[JsonKeys::LAENGS_STREUUNG()] = streuungsdaten.laengsstreuung;
  data[JsonKeys::SEITEN_STREUUNG()] = streuungsdaten.seitenstreuung;
  data[JsonKeys::LAENGS_STREUUNG_H()] = streuungsdaten.laengsstreuungH;
  data[JsonKeys::SEITEN_STREUUNG_H()] = streuungsdaten.seitenstreuungH;
}

//************************
// EX-L45 Anmeldebestaetigung Fehlercode
void anBestaetigungsdatenFromJson(const QJsonObject &data, AnBestaetigungsdaten &anBestaetigungsdaten, bool &bOk)
{
  bOk = true;
  bOk &= data.contains(JsonKeys::ERRORTEXT());

  if (!bOk)
    return;
  anBestaetigungsdaten.error = AnmeldebestaetigungFehlercodeMap.value(data[JsonKeys::ERRORTEXT()].toString());
};

void SAATELEGRAMS_EXPORT anBestaetigungsdatenToJson(QJsonObject &data, const AnBestaetigungsdaten &anBestaetigungsdaten)
{
  data[JsonKeys::ERRORTEXT()] = AnmeldebestaetigungFehlercodeMap.key(anBestaetigungsdaten.error);
}
//************************
// EX-L47 Rakete Trefferpunkt
void treffpunktfromJson(const QJsonObject &data, Treffpunkt &treffpunkt, bool &bOk)
{
  koordinateMitHoeheFromJson(data[JsonKeys::KOORDINATE()].toObject(), treffpunkt.koordinate, bOk); // EX-L14
  treffpunkt.anzahl = toInteger(data[JsonKeys::ANZAHL()], bOk);
}

void treffpunktefromJson(const QJsonArray &data, QVector<Treffpunkt> &treffpunkte, bool &bOk)
{
  for (const QJsonValue &val : qAsConst(data))
  {
    Treffpunkt treffpunkt;
    treffpunktfromJson(val.toObject(), treffpunkt, bOk);
    treffpunkte.append(treffpunkt);
  }
}

//************************
// EX-L49 Wirkmittel Feuerkommando Rakete
void wirkmittelFeuerkommandoRaketeFromJson(const QJsonObject &data, WirkmittelFeuerkommandoRakete &wirkmittelFeuerkommandoRakete, bool &bOk)
{
  bOk = true;
  // bOk &= data.contains(JsonKeys::KENNER());
  // bOk &= data.contains(JsonKeys::FLUGZEIT());
  // bOk &= data.contains(JsonKeys::GIPFELHOEHE());
  // bOk &= data.contains(JsonKeys::SCHUSSRICHTUNG());
  // bOk &= data.contains(JsonKeys::GESCHOSS());

  // if (!bOk)
  // {
  //   qDebug() << "wirkmittelFeuerkommandoRaketeFromJson bOk=false";
  //   //return;
  // }

  wirkmittelFeuerkommandoRakete.kenner = waffensystemkennerMap.value(data[JsonKeys::KENNER()].toString()); // EX-L27
  treffpunktefromJson(data[JsonKeys::TREFFPUNKTE()].toArray(), wirkmittelFeuerkommandoRakete.treffpunkte, bOk);
  wirkmittelFeuerkommandoRakete.flugzeit = toDouble(data[JsonKeys::FLUGZEIT()], bOk);
  wirkmittelFeuerkommandoRakete.gipfelhoehe = toInteger(data[JsonKeys::GIPFELHOEHE()], bOk);
  wirkmittelFeuerkommandoRakete.schussrichtung = toDouble(data[JsonKeys::SCHUSSRICHTUNG()], bOk);
  wirkmittelFeuerkommandoRakete.fallwinkel = toInteger(data[JsonKeys::FALLWINKEL()], bOk);
  wirkmittelFeuerkommandoRakete.anflug = TrajectoryRocketMap.value(data[JsonKeys::ANFLUG()].toString());              // EX-L48
  feuerkommandoGeschosseFromJson(data[JsonKeys::GESCHOSS()].toObject(), wirkmittelFeuerkommandoRakete.geschoss, bOk); // EX-L36
  wirkmittelFeuerkommandoRakete.gps = GpsFrequencyMap.value(data[JsonKeys::GPS()].toString());
  wirkmittelFeuerkommandoRakete.wirkzeit = toInteger(data[JsonKeys::WIRKZEIT()], bOk);
}

void trefferpunktToJson(QJsonObject &data, const Treffpunkt &treffpunkt)
{
  QJsonObject koordinate;
  koordinateMitHoeheToJson(koordinate, treffpunkt.koordinate);
  data[JsonKeys::KOORDINATE()] = koordinate;
  data[JsonKeys::ANZAHL()] = treffpunkt.anzahl;
}

void trefferpunkteToJson(QJsonArray &data, const QVector<Treffpunkt> &treffpunkte)
{
  for (const auto &treffpunkt : qAsConst(treffpunkte))
  {
    QJsonObject trp;
    trefferpunktToJson(trp, treffpunkt);
    data.append(trp);
  }
}

void wirkmittelFeuerkommandoRaketeToJson(QJsonObject &data, const WirkmittelFeuerkommandoRakete &wirkmittelFeuerkommandoRakete)
{
  data[JsonKeys::KENNER()] = waffensystemkennerMap.key(wirkmittelFeuerkommandoRakete.kenner);

  QJsonArray objTrefferpunkte;
  trefferpunkteToJson(objTrefferpunkte, wirkmittelFeuerkommandoRakete.treffpunkte);
  data[JsonKeys::TREFFPUNKTE()] = objTrefferpunkte;
  data[JsonKeys::FLUGZEIT()] = wirkmittelFeuerkommandoRakete.flugzeit;
  data[JsonKeys::GIPFELHOEHE()] = wirkmittelFeuerkommandoRakete.gipfelhoehe;
  data[JsonKeys::SCHUSSRICHTUNG()] = wirkmittelFeuerkommandoRakete.schussrichtung;
  data[JsonKeys::FALLWINKEL()] = wirkmittelFeuerkommandoRakete.fallwinkel;
  data[JsonKeys::ANFLUG()] = ProjectDataManagement::toString(wirkmittelFeuerkommandoRakete.anflug);
  data[JsonKeys::GPS()] = ProjectDataManagement::toString(wirkmittelFeuerkommandoRakete.gps);
  data[JsonKeys::WIRKZEIT()] = wirkmittelFeuerkommandoRakete.wirkzeit;
  QJsonObject objGeschoss;
  feuerkommandoGeschosseToJson(objGeschoss, wirkmittelFeuerkommandoRakete.geschoss);
  data[JsonKeys::GESCHOSS()] = objGeschoss;
}

void wirkmittelFeuerkommandosRaketeToJson(QJsonArray &data, const QVector<WirkmittelFeuerkommandoRakete> &wirkmittelFeuerkommandoRakete)
{
  for (const auto &feuerkommandoRakete : qAsConst(wirkmittelFeuerkommandoRakete))
  {
    QJsonObject fkr;
    wirkmittelFeuerkommandoRaketeToJson(fkr, feuerkommandoRakete);
    data.append(fkr);
  }
}
//************************

// EX-FQ(BA-BB-FK) Wirkfeldplanung
void SAATELEGRAMS_EXPORT wirkfeldplanungDataFromJson(const QJsonObject &data, WirkfeldplanungData &wirkfeldplanungData, bool &bOk)
{
  bOk = true;
  bOk &= data.contains(JsonKeys::ZIELDATEN());
  bOk &= data.contains(JsonKeys::ABFEUERUNGSART());
  bOk &= data.contains(JsonKeys::FORDERUNG());
  bOk &= data.contains(JsonKeys::DAUER());
  bOk &= data.contains(JsonKeys::FEUERKOMMANDO());

  if (!bOk)
    return;

  if (data[JsonKeys::FEUERKAMPFREFERENZ()].isNull() || !data.contains(JsonKeys::FEUERKAMPFREFERENZ()))
  {
    wirkfeldplanungData.feuerkampfReferenz = QString();
  }
  else
  {
    wirkfeldplanungData.feuerkampfReferenz = data[JsonKeys::FEUERKAMPFREFERENZ()].toString();
  }

  feuerkommandoFromJson(data[JsonKeys::FEUERKOMMANDO()].toObject(), wirkfeldplanungData.feuerkommando, bOk);

  zieldatenfromJson(data[JsonKeys::ZIELDATEN()].toObject(), wirkfeldplanungData.zieldaten, bOk);
  wirkfeldplanungData.abfeuerungsArt = AbfeuerungsartMap.value(data[JsonKeys::ABFEUERUNGSART()].toString());
  wirkfeldplanungData.forderung = ForderungMap.value(data[JsonKeys::FORDERUNG()].toString());
  wirkfeldplanungData.dauer = toInteger(data[JsonKeys::DAUER()], bOk);
}

// 7.3.9 EX-Fuehrungsdaten
void SAATELEGRAMS_EXPORT fuehrungsdatenFromJson(const QJsonObject &data, Fuehrungsdaten &fuehrungsdaten, bool &bOk)
{
  fuehrungsdaten.art = art_L24Map.value(data[JsonKeys::ART()].toString()); // EX-L24
  fuehrungsdaten.name = data[JsonKeys::NAME()].toString();
  fuehrungsdaten.meldungsnummer = data[JsonKeys::MELDUNGSNUMMER()].toInt();
  zeitangabe_DTGFromJson(data[JsonKeys::AB()].toObject(), fuehrungsdaten.ab, bOk);   // EX-L15
  zeitangabe_DTGFromJson(data[JsonKeys::BIS()].toObject(), fuehrungsdaten.bis, bOk); // EX-L15
  QJsonArray koordinatenArray = data[JsonKeys::KOORDINATEN()].toArray();
  for (const QJsonValue &value : qAsConst(koordinatenArray))
  {
    Koordinate koordinate;
    koordinatefromJson(value.toObject(), koordinate, bOk); // EX-L13
    fuehrungsdaten.koordinaten.append(koordinate);
  }
  fuehrungsdaten.linkerNachbar = data[JsonKeys::LINKERNACHBAR()].toString();
  fuehrungsdaten.rechterNachbar = data[JsonKeys::RECHTERNACHBAR()].toString();
}

void SAATELEGRAMS_EXPORT fuehrungsdatenToJson(QJsonObject &data, const Fuehrungsdaten &fuehrungsdaten)
{
  data[JsonKeys::ART()] = art_L24Map.key(fuehrungsdaten.art);
  data[JsonKeys::NAME()] = fuehrungsdaten.name;
  data[JsonKeys::MELDUNGSNUMMER()] = fuehrungsdaten.meldungsnummer;

  QJsonObject objTimestamp;
  zeitangabe_DTGToJson(objTimestamp, fuehrungsdaten.ab);
  data[JsonKeys::AB()] = objTimestamp;
  zeitangabe_DTGToJson(objTimestamp, fuehrungsdaten.bis);
  data[JsonKeys::BIS()] = objTimestamp;

  QJsonArray koordinatenArray;
  for (const auto &koordinate : qAsConst(fuehrungsdaten.koordinaten))
  {
    QJsonObject objKoordinate;
    koordinateToJson(objKoordinate, koordinate);
    koordinatenArray.append(objKoordinate);
  }
  data[JsonKeys::KOORDINATEN()] = koordinatenArray;
  data[JsonKeys::LINKERNACHBAR()] = fuehrungsdaten.linkerNachbar;
  data[JsonKeys::RECHTERNACHBAR()] = fuehrungsdaten.rechterNachbar;
}

// 7.2.22 EX-Flugbahnberechnung
void SAATELEGRAMS_EXPORT exFlugbahnberechnungDatenFromJson(const QJsonObject &data, FlugBerechnungsDaten &flugBerechnungsDaten, bool &bOk)
{
  bOk = true;
  bOk &= data.contains(JsonKeys::STANDORT());
  bOk &= data.contains(JsonKeys::ZIELKOORDINATE());
  bOk &= data.contains(JsonKeys::WAFFENSYSTEM());
  bOk &= data.contains(JsonKeys::GESCHOSS());
  bOk &= data.contains(JsonKeys::SPRENGHOEHE());
  bOk &= data.contains(JsonKeys::WINKELGRUPPE());

  if (!bOk)
    return;

  koordinateMitHoeheFromJson(data[JsonKeys::STANDORT()].toObject(), flugBerechnungsDaten.standort, bOk);             // EX-L14
  koordinateMitHoeheFromJson(data[JsonKeys::ZIELKOORDINATE()].toObject(), flugBerechnungsDaten.zielkoordinate, bOk); // EX-L14

  flugBerechnungsDaten.waffensystem = waffensystemtypMap.value(data[JsonKeys::WAFFENSYSTEM()].toString()); // EX-L26
  flugbahnberechnungGeschosseFromJson(data[JsonKeys::GESCHOSS()].toObject(), flugBerechnungsDaten.geschoss, bOk);
  flugBerechnungsDaten.sprenghoehe = toInteger(data[JsonKeys::SPRENGHOEHE()], bOk);
  flugBerechnungsDaten.winkelgruppe = winkelgruppeMap.value(data[JsonKeys::WINKELGRUPPE()].toString());
}

void SAATELEGRAMS_EXPORT exFlugbahnberechnungDatenToJson(QJsonObject &data, const FlugBerechnungsDaten &flugBerechnungsDaten)
{
  QJsonObject koordinate;
  koordinateMitHoeheToJson(koordinate, flugBerechnungsDaten.standort);
  data[JsonKeys::STANDORT()] = koordinate;
  koordinateMitHoeheToJson(koordinate, flugBerechnungsDaten.zielkoordinate);
  data[JsonKeys::ZIELKOORDINATE()] = koordinate;
  data[JsonKeys::WAFFENSYSTEM()] = waffensystemtypMap.key(flugBerechnungsDaten.waffensystem);
  QJsonObject geschoss;
  FlugbahnberechnungGeschosseToJson(geschoss, flugBerechnungsDaten.geschoss);
  data[JsonKeys::GESCHOSS()] = geschoss;
  data[JsonKeys::SPRENGHOEHE()] = flugBerechnungsDaten.sprenghoehe;
  data[JsonKeys::WINKELGRUPPE()] = winkelgruppeMap.key(flugBerechnungsDaten.winkelgruppe);
}

// 7.2.23 EX-Flugbahndaten
void SAATELEGRAMS_EXPORT flugbahndatenFromJson(const QJsonObject &data, Flugbahndaten &flugbahndaten, bool &bOk)
{
  flugbahndaten.fehlercode = FehlercodeMap.value(data[JsonKeys::FEHLERCODE()].toString());
  if (flugbahndaten.fehlercode == FlugbahnberechnungFehlercode::Ok)
  {
    koordinateMitHoeheFromJson(data[JsonKeys::ZIELKOORDINATE()].toObject(), flugbahndaten.zielkoordinate, bOk);
    flugbahndaten.waffensystem = waffensystemtypMap.value(data[JsonKeys::TYP()].toString());
    flugbahndaten.flugzeit = toDouble(data[JsonKeys::FLUGZEIT()], bOk);
    flugbahndaten.gipfelhoehe = toInteger(data[JsonKeys::GIPFELHOEHE()], bOk);
    flugbahndaten.schussrichtung = toDouble(data[JsonKeys::SCHUSSRICHTUNG()], bOk);
    flugbahndaten.fallwinkel = toInteger(data[JsonKeys::FALLWINKEL()], bOk);

    QJsonArray flugbahnpunkteArray = data[JsonKeys::FLUGBAHNPUNKT()].toArray();
    for (const QJsonValue &value : qAsConst(flugbahnpunkteArray))
    {
      Flugbahnpunkt flugbahnpunkt;
      flugbahnpunktFromJson(value.toObject(), flugbahnpunkt, bOk); // EX-L13
      flugbahndaten.flugbahnpunkt.append(flugbahnpunkt);
    }
    if (data[JsonKeys::STREUUNG()].isNull() || !data.contains(JsonKeys::STREUUNG()))
    {
      flugbahndaten.streuung.laengsstreuung = 0.0;
      flugbahndaten.streuung.laengsstreuungH = 0.0;
      flugbahndaten.streuung.seitenstreuung = 0.0;
      flugbahndaten.streuung.seitenstreuungH = 0.0;
    }
    else
      streuungsdatenFromJson(data[JsonKeys::STREUUNG()].toObject(), flugbahndaten.streuung, bOk);       // EX-L39
    FlugbahndatenGeschosseFromJson(data[JsonKeys::GESCHOSS()].toObject(), flugbahndaten.geschoss, bOk); // EX-L39
  }
}

void SAATELEGRAMS_EXPORT flugbahndatenToJson(QJsonObject &data, const Flugbahndaten &flugbahndaten)
{
  data[JsonKeys::FEHLERCODE()] = FehlercodeMap.key(flugbahndaten.fehlercode);
  QJsonObject objKoordinate;
  koordinateMitHoeheToJson(objKoordinate, flugbahndaten.zielkoordinate);
  data[JsonKeys::ZIELKOORDINATE()] = objKoordinate;
  data[JsonKeys::TYP()] = waffensystemtypMap.key(flugbahndaten.waffensystem);
  data[JsonKeys::FLUGZEIT()] = flugbahndaten.flugzeit;
  data[JsonKeys::GIPFELHOEHE()] = flugbahndaten.gipfelhoehe;
  data[JsonKeys::SCHUSSRICHTUNG()] = flugbahndaten.schussrichtung;
  data[JsonKeys::FALLWINKEL()] = flugbahndaten.fallwinkel;

  QJsonArray flugbahnpunkte;
  for (const auto &flugbahnpunkt : qAsConst(flugbahndaten.flugbahnpunkt))
  {
    QJsonObject flugbahnpunktObj;
    flugbahnpunktToJson(flugbahnpunktObj, flugbahnpunkt);
    flugbahnpunkte.append(flugbahnpunktObj);
  }
  data[JsonKeys::FLUGBAHNPUNKT()] = flugbahnpunkte;
  QJsonObject streuungsdatenObj;
  streuungsdatenToJson(streuungsdatenObj, flugbahndaten.streuung);
  data[JsonKeys::STREUUNG()] = streuungsdatenObj;
  QJsonObject geschossObj;
  FlugbahndatenGeschosseToJson(geschossObj, flugbahndaten.geschoss);
  data[JsonKeys::GESCHOSS()] = geschossObj;
}

// EX-Anmeldedaten
void SAATELEGRAMS_EXPORT anmeldedatenFromJson(const QJsonObject &data, Anmeldedaten &anmeldedaten, bool &bOk)
{
  bOk = true;
  anmeldedaten.partyId = data[JsonKeys::PARTY_ID()].toInt();
  anmeldedaten.adlerVerbund = data[JsonKeys::ADLER_VERBUND()].toBool();
  anmeldedaten.szenar = data[JsonKeys::SZENAR()].toString();
}

// EX-Abmeldedaten
void SAATELEGRAMS_EXPORT abmeldedatenFromJson(const QJsonObject &data, Abmeldedaten &abmeldedaten, bool &bOk)
{
  bOk = true;
  abmeldedaten.partyId = data[JsonKeys::PARTY_ID()].toInt();
}

// EX-TechnischeDaten
void SAATELEGRAMS_EXPORT technischeDatenFromJson(const QJsonObject &data, TechnischeDaten &technischeDaten, bool &bOk)
{
  bOk = true;
  technischeDaten.status = StatusL32Map.value(data[JsonKeys::STATUS()].toString());
  technischeDaten.beschreibung = data[JsonKeys::BESCHREIBUNG()].toString();
};

void SAATELEGRAMS_EXPORT technischeDatenToJson(QJsonObject &data, const TechnischeDaten &technischeDaten)
{
  data[JsonKeys::STATUS()] = StatusL32Map.key(technischeDaten.status);
  data[JsonKeys::BESCHREIBUNG()] = technischeDaten.beschreibung;
}

// EX-EX-Freitextdaten
void SAATELEGRAMS_EXPORT freitextdatenToJson(QJsonObject &data, const FreitextDaten &freitextDaten) { data[JsonKeys::TEXTVAL()] = freitextDaten.text; };

void SAATELEGRAMS_EXPORT FreitextDatenFromJson(const QJsonObject &data, FreitextDaten &freitextDaten, bool &bOk)
{
  bOk = true;
  freitextDaten.text = data[JsonKeys::TEXTVAL()].toString();
}

// EX-MQ Manuelle Quittung
void SAATELEGRAMS_EXPORT mqManuelleQuittungDatenToJson(QJsonObject &data, const ManuelleQuittungDaten &manuelleQuittungDaten)
{
  data[JsonKeys::FEUERKAMPFREFERENZ()] = manuelleQuittungDaten.feuerkampfreferenz;
};

void SAATELEGRAMS_EXPORT mqManuelleQuittungDatenFromJson(const QJsonObject &data, ManuelleQuittungDaten &manuelleQuittungDaten, bool &bOk)
{
  bOk = true;
  manuelleQuittungDaten.feuerkampfreferenz = data[JsonKeys::FEUERKAMPFREFERENZ()].toString();
}

void SAATELEGRAMS_EXPORT exNichtFeuernFromJson(const QJsonObject &data, Feuerkampfdaten &feuerkampfdaten, bool &bOk)
{
  bOk = true;
  feuerkampfdaten.feuerkampfReferenz = data[JsonKeys::FEUERKAMPFREFERENZ()].toString();
  feuerkampfdaten.kenner = waffensystemkennerMap.value(data[JsonKeys::KENNER()].toString());
  feuerkampfdaten.verein = data[JsonKeys::VEREIN()].toString();
}

// EX-FeuerHaltDaten
void SAATELEGRAMS_EXPORT feuerHaltDatenFromJson(const QJsonObject &data, FeuerHaltDaten &feuerHaltDaten, bool &bOk)
{
  feuerHaltDaten.verein = data[JsonKeys::VEREIN()].toString();
  feuerHaltDaten.kenner = waffensystemkennerMap.value(data[JsonKeys::KENNER()].toString());
  feuerHaltDaten.kategorie = feuerHaltKategorieMap.value(data[JsonKeys::KATEGORIE()].toString());
  feuerHaltDaten.feuerkampfReferenz = data[JsonKeys::FEUERKAMPFREFERENZ()].toString();

  if (data[JsonKeys::ZPNUMMER()].isNull() || !data.contains(JsonKeys::ZPNUMMER()))
    feuerHaltDaten.zpNummer = -1.0;
  else
    feuerHaltDaten.zpNummer = data[JsonKeys::ZPNUMMER()].toInt();

  koordinatefromJson(data[JsonKeys::KOORDINATE()].toObject(), feuerHaltDaten.koordinate, bOk); // EX-L13
  feuerHaltDaten.radius = data[JsonKeys::RADIUS()].toInt();
  feuerHaltDaten.entladenSchuss = data[JsonKeys::ENTLADENSCHUSS()].toBool();
};

void SAATELEGRAMS_EXPORT feuerHaltDatenToJson(QJsonObject &data, const FeuerHaltDaten &feuerHaltDaten)
{
  data[JsonKeys::VEREIN()] = feuerHaltDaten.verein;
  data[JsonKeys::KENNER()] = waffensystemkennerMap.key(feuerHaltDaten.kenner);
  data[JsonKeys::KATEGORIE()] = feuerHaltKategorieMap.key(feuerHaltDaten.kategorie);
  data[JsonKeys::FEUERKAMPFREFERENZ()] = feuerHaltDaten.feuerkampfReferenz;
  data[JsonKeys::ZPNUMMER()] = feuerHaltDaten.zpNummer;
  QJsonObject koordinate;
  koordinateToJson(koordinate, feuerHaltDaten.koordinate);
  data[JsonKeys::KOORDINATE()] = koordinate;
  data[JsonKeys::RADIUS()] = feuerHaltDaten.radius;
  data[JsonKeys::ENTLADENSCHUSS()] = feuerHaltDaten.entladenSchuss;
}

// EX-Statusdaten
void SAATELEGRAMS_EXPORT statusFromJson(const QJsonObject &data, EXStatus &eXStatus, bool &bOk)
{
  bOk = true;
  eXStatus.status = szenarstatusMap.value(data[JsonKeys::STATUS()].toString());
}
//////////////////////////////////////////////////////
/// \brief ExAwesPlanning::toJsonInternal
/// \return
///
template <> QJsonObject ExAwesPlanning::toJsonInternal<ExAwesPlanning>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  data[JsonKeys::FEUERKAMPFREFERENZ()] = wirkfeldplanungData.feuerkampfReferenz;
  QJsonObject objZieldaten;
  zieldatenToJson(objZieldaten, wirkfeldplanungData.zieldaten);
  data[JsonKeys::ZIELDATEN()] = objZieldaten;
  data[JsonKeys::ABFEUERUNGSART()] = AbfeuerungsartMap.key(wirkfeldplanungData.abfeuerungsArt);
  data[JsonKeys::FORDERUNG()] = ForderungMap.key(wirkfeldplanungData.forderung);
  data[JsonKeys::DAUER()] = wirkfeldplanungData.dauer;

  QJsonObject objFeuerkommando;
  feuerkommandoToJson(objFeuerkommando, wirkfeldplanungData.feuerkommando);
  data[JsonKeys::FEUERKOMMANDO()] = objFeuerkommando;

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject ExAwesPlanning::toJson() { return toJsonInternal<ExAwesPlanning>(); }

//////////////////////////////////////////////////////
/// \brief ExFeuerbereit::toJsonInternal
/// \return
///
template <> QJsonObject ExFeuerbereit::toJsonInternal<ExFeuerbereit>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  feuerkampfdatenToJson(data, feuerkampfdaten);

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject ExFeuerbereit::toJson() { return toJsonInternal<ExFeuerbereit>(); }
//////////////////////////////////////////////////////
/// \brief ExFeuern::toJsonInternal
/// \return
///
template <> QJsonObject ExFeuern::toJsonInternal<ExFeuern>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  feuerkampfdatenToJson(data, feuerkampfdaten);

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject ExFeuern::toJson() { return toJsonInternal<ExFeuern>(); }
//////////////////////////////////////////////////////
/// \brief ExAbgefeuert::toJsonInternal
/// \return
///
template <> QJsonObject ExAbgefeuert::toJsonInternal<ExAbgefeuert>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  feuerkampfdatenToJson(data, feuerkampfdaten);

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject ExAbgefeuert::toJson() { return toJsonInternal<ExAbgefeuert>(); }

//////////////////////////////////////////////////////
/// \brief ExVollzugsmeldung::toJsonInternal
/// \return
///
template <> QJsonObject ExVollzugsmeldung::toJsonInternal<ExVollzugsmeldung>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  feuerkampfdatenToJson(data, feuerkampfdaten);

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject ExVollzugsmeldung::toJson() { return toJsonInternal<ExVollzugsmeldung>(); }

//////////////////////////////////////////////////////
/// \brief ExAbgefeuert::toJsonInternal
/// \return
///
// template<>
// QJsonObject ExErkundungsanfrage::toJsonInternal<ExErkundungsanfrage>()
// {
//   QJsonObject obj = static_cast<EXTelegramBase*>(this)->toJsonInternal<EXTelegramBase>();

//   QJsonObject data;

//   obj[JsonKeys::DATA()] = data;

//   return obj;
// }

// QJsonObject ExErkundungsanfrage::toJson()
// {
//   return toJsonInternal<ExErkundungsanfrage>();
// }

//////////////////////////////////////////////////////
/// \brief ExErkundungsergebnisse::toJsonInternal
/// \return
///
template <> QJsonObject ExErkundungsergebnisse::toJsonInternal<ExErkundungsergebnisse>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  erkundungsdatenToJson(data, erkundungsdaten);

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject ExErkundungsergebnisse::toJson() { return toJsonInternal<ExErkundungsergebnisse>(); }

//////////////////////////////////////////////////////
/// \brief ExFeuerkampf::toJsonInternal
/// \return
///
template <> QJsonObject ExFeuerkampf::toJsonInternal<ExFeuerkampf>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  zielmeldedatenToJson(data, zielmeldedaten);

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject ExFeuerkampf::toJson() { return toJsonInternal<ExFeuerkampf>(); }
//////////////////////////////////////////////////////
/// \brief ExFeuerhalt::toJsonInternal
/// \return
///
template <> QJsonObject ExFeuerhalt::toJsonInternal<ExFeuerhalt>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  feuerHaltDatenToJson(data, feuerHaltDaten);

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject ExFeuerhalt::toJson() { return toJsonInternal<ExFeuerhalt>(); }

//////////////////////////////////////////////////////
/// \brief ExFeuerstellungFS::toJsonInternal
/// \return
///
template <> QJsonObject ExFeuerstellungFS::toJsonInternal<ExFeuerstellungFS>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  feuerstellungsdatenToJson(data, feuerstellungsdaten);

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject ExFeuerstellungFS::toJson() { return toJsonInternal<ExFeuerstellungFS>(); }

//////////////////////////////////////////////////////
/// \brief ExFeuerstellungWS::toJsonInternal
/// \return
///
template <> QJsonObject ExFeuerstellungWS::toJsonInternal<ExFeuerstellungWS>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  waffensystemdatenToJson(data, waffensystemdaten);

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject ExFeuerstellungWS::toJson() { return toJsonInternal<ExFeuerstellungWS>(); }

//////////////////////////////////////////////////////
/// \brief ExFeuerstellungLP::toJsonInternal
/// \return
///
template <> QJsonObject ExFeuerstellungLP::toJsonInternal<ExFeuerstellungLP>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  ladeplatzdatenToJson(data, ladeplatzdaten);

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject ExFeuerstellungLP::toJson() { return toJsonInternal<ExFeuerstellungLP>(); }

//////////////////////////////////////////////////////
/// \brief ExStellungswechsel::toJsonInternal
/// \return
///
template <> QJsonObject ExStellungswechsel::toJsonInternal<ExStellungswechsel>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  stellungswechseldatenToJson(data, stellungswechseldaten);

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject ExStellungswechsel::toJson() { return toJsonInternal<ExStellungswechsel>(); }

//////////////////////////////////////////////////////
/// \brief ExHqKoordinierungsmassnahmen::toJsonInternal
/// \return
///
template <> QJsonObject ExHqKoordinierungsmassnahmen::toJsonInternal<ExHqKoordinierungsmassnahmen>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  koordinierungsdatenToJson(data, koordinierungsdaten);

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject ExHqKoordinierungsmassnahmen::toJson() { return toJsonInternal<ExHqKoordinierungsmassnahmen>(); }

//////////////////////////////////////////////////////
/// \brief ExHqKoordinierungsmassnahmen::toJsonInternal
/// \return
///
template <> QJsonObject ExHqFuehrungslinien::toJsonInternal<ExHqFuehrungslinien>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  fuehrungsdatenToJson(data, fuehrungsdaten);

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject ExHqFuehrungslinien::toJson() { return toJsonInternal<ExHqFuehrungslinien>(); }

//////////////////////////////////////////////////////
/// \brief EX-TQ Technische Quittierung
/// \return
///
template <> QJsonObject ExTqTechnischeQuittung::toJsonInternal<ExTqTechnischeQuittung>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  technischeDatenToJson(data, technischeDaten);

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject ExTqTechnischeQuittung::toJson() { return toJsonInternal<ExTqTechnischeQuittung>(); }

//////////////////////////////////////////////////////
/// \brief 7.1.23 EX-AQ Freitextmeldung
/// \return
///
template <> QJsonObject ExAqFreitextmeldung::toJsonInternal<ExAqFreitextmeldung>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  freitextdatenToJson(data, freitextDaten);

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject ExAqFreitextmeldung::toJson() { return toJsonInternal<ExAqFreitextmeldung>(); }

//////////////////////////////////////////////////////
/// \brief EX-MQ Manuelle Quittung
/// \return
///
template <> QJsonObject ExMqManuelleQuittung::toJsonInternal<ExMqManuelleQuittung>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  mqManuelleQuittungDatenToJson(data, mqManuelleQuittungDaten);

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject ExMqManuelleQuittung::toJson() { return toJsonInternal<ExMqManuelleQuittung>(); }
//////////////////////////////////////////////////////
/// \brief EX-Flugbahnberechnung
/// \return
///
template <> QJsonObject ExFlugbahnberechnung::toJsonInternal<ExFlugbahnberechnung>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  exFlugbahnberechnungDatenToJson(data, flugbahnberechnungDaten);

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject ExFlugbahnberechnung::toJson() { return toJsonInternal<ExFlugbahnberechnung>(); }
//////////////////////////////////////////////////////
/// \brief EX-Flugbahndaten
/// \return
///
template <> QJsonObject ExFlugbahndaten::toJsonInternal<ExFlugbahndaten>()
{
  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  flugbahndatenToJson(data, flugbahndaten);

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject ExFlugbahndaten::toJson() { return toJsonInternal<ExFlugbahndaten>(); }

template <> QJsonObject exNichtFeuern::toJsonInternal<exNichtFeuern>()
{

  QJsonObject obj = static_cast<EXTelegramBase *>(this)->toJsonInternal<EXTelegramBase>();

  QJsonObject data;
  feuerkampfdatenToJson(data, feuerkampfdaten);

  obj[JsonKeys::DATA()] = data;

  return obj;
}

QJsonObject exNichtFeuern::toJson() { return toJsonInternal<exNichtFeuern>(); }

//////////////////////////////////////////////////////
/// \brief szenarstatusToStr
/// \param status
/// \return
///
QString szenarstatusToStr(Szenarstatus status) { return szenarstatusMap.key(status); }

Szenarstatus strToSzenarstatus(QString status) { return szenarstatusMap.value(status); }

int getFeuerkommandoRaketeEffectDurationMsec(const QJsonObject &data)
{
  bool bOk = false;
  int wirkzeitMsec;
  switch (toInteger(data[JsonKeys::WIRKZEIT()], bOk)){
  case 1:
    wirkzeitMsec = 3 * 60 * 60 * 1000;
    break;
  case 2:
    wirkzeitMsec = 6 * 60 * 60 * 1000;
    break;
  case 3:
    wirkzeitMsec = 12 * 60 * 60 * 1000;
    break;
  case 4:
    wirkzeitMsec = 24 * 60 * 60 * 1000;
    break;
  case 5:
    wirkzeitMsec = 48 * 60 * 60 * 1000;
    break;
  case 6:
    wirkzeitMsec = 96 * 60 * 60 * 1000;
    break;
  default:
    wirkzeitMsec = 3 * 60 * 60 * 1000;
    break;
  }

  return wirkzeitMsec;
}

} // namespace AdlerJson