qt5-legatus-legacy/Lts/Services/ParticipantManagement/TargetHandling/object_target_information.cpp

/**
  * Handler ShootbackTargets (L400)
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by N. Thoden, SLTE, 31.05.2022
  */

#include "object_target_information.h"
#include "../main_handler.h"

#include <QJsonDocument>
#include <QDebug>


//------------------------------------------------------------------------------
namespace ParticipantManagement
{

//
// Core::GeoPosition2D
Core::GeoPosition2D posFromJson(const QJsonValue &val)
{
  const QJsonObject objElement(val.toObject());
  Core::GeoPosition2D element;
  {
    const QJsonValue valLon(objElement.value(QStringLiteral("lon")));
    element.lon(valLon.toDouble());
  }
  {
    const QJsonValue valLat(objElement.value(QStringLiteral("lat")));
    element.lat(valLat.toDouble());
  }
  return element;
}
QJsonObject toJson(const Core::GeoPosition2D &element)
{
  QJsonObject obj;
  obj[QStringLiteral("lon")] = element.lon();
  obj[QStringLiteral("lat")] = element.lat();
  return obj;
}

//
// ShootbackArea
ShootbackArea areaFromJson(const QJsonValue &val)
{
  ShootbackArea area;
  // use val.toObject().value instead val[key] introduced with qt5.10
  area.identifier(val.toObject().value(QStringLiteral("identifier")).toString().toStdString());

  if (val.toObject().value(QStringLiteral("coords")).isArray())
  {
    const QJsonArray &arr = val.toObject().value(QStringLiteral("coords")).toArray();
    if (arr.size() > 0)      area.coord1( posFromJson(arr.at(0)) );
    if (arr.size() > 1)      area.coord2( posFromJson(arr.at(1)) );
    if (arr.size() > 2)      area.coord3( posFromJson(arr.at(2)) );
    if (arr.size() > 3)      area.coord4( posFromJson(arr.at(3)) );
  }
  return area;
}

QJsonObject toJson(const ShootbackArea &area)
{
  QJsonObject obj;
  obj.insert(QStringLiteral("identifier"), QString::fromStdString(area.identifier()));

  QJsonArray arr;
  arr.push_back(toJson(area.coord1()));
  arr.push_back(toJson(area.coord2()));
  arr.push_back(toJson(area.coord3()));
  arr.push_back(toJson(area.coord4()));
  obj.insert(QStringLiteral("coords"), arr);
  return obj;
}

//
// vector<ShootbackArea>
QJsonObject toJson(const std::vector<ShootbackArea>& shootback_areas)
{
  if (shootback_areas.size() == 0)
    return {};
  QJsonArray arr;
  for (const ShootbackArea &area : shootback_areas)
    arr.push_back(toJson(area));

  QJsonObject obj;
  obj.insert(QStringLiteral("shootback_areas"), arr);
  return obj;
}

std::vector<ShootbackArea> vecfromJson(const QJsonValue &val)
{
  std::vector<ShootbackArea> ret;
  if (val.isNull())
    return ret;

  // use val.toObject().value instead val[key] introduced with qt5.10
  if (val.toObject().value(QStringLiteral("shootback_areas")).isArray())
  {
    const QJsonArray &arr = val.toObject().value(QStringLiteral("shootback_areas")).toArray();
    ret.reserve(arr.size());
    for (const auto& item : arr)
      ret.push_back(areaFromJson(item));
  }

  return ret;
}


ObjectTargetInformation::ObjectTargetInformation(MainHandler *mainHandler)
  : m_mainHandler(mainHandler)
  , m_logger(getLogger("ObjectTargetInformation"))
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
}

//------------------------------------------------------------------------------
ObjectTargetInformation::~ObjectTargetInformation()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  if (isValid())
    m_mainHandler->dts()->removeTargetInformationByKey(m_data.id());
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
}

//------------------------------------------------------------------------------
bool ObjectTargetInformation::isValid() const
{
  return m_data.id() > 0;
}

//------------------------------------------------------------------------------
Core::FunctionReplyObject ObjectTargetInformation::createObject(const TargetInformation &data)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";
  m_data = data;

  if (m_data.id() <= 0)
  {
    Database::PpmTargetInformation dbData(toDbData(data));

    if (!m_mainHandler->db()->insert(dbData))
      return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting TargetInformation-data into database"));

    m_data.id(dbData.id);
    DEBUG_LOG(m_logger) << "New PpmTargetInformation: " /*<< m_data.id()*/;
  }

  // Publish Data via DTS
  onPublishData();

  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return Core::FunctionReplyObject(m_data.id());
}

//------------------------------------------------------------------------------
Core::FunctionReplyObject ObjectTargetInformation::updateObject(const TargetInformation &data)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START, participantId=" << data.participantId()
                      << " size =" << data.shootbackAreas().size();
  Database::PpmTargetInformation dbData;
  dbData = toDbData(data);

  if (!m_mainHandler->db()->update(dbData))
    return Core::FunctionReplyObject(data.id(), tr_lts("dds", "Error updating TargetInformation-data into database"));

  m_data = data;
  DEBUG_LOG(m_logger) << "Data changed for TargetInformation: " << m_data.participantId();

  // Publish Data via DTS
  onPublishData();

  TRACE_LOG(m_logger) << LOGFUNCTION << " END, id=" << data.id()
                      << " size =" << data.shootbackAreas().size();
  return Core::FunctionReplyObject(m_data.id());
}

//------------------------------------------------------------------------------
Core::FunctionReplyObject ObjectTargetInformation::removeObject()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  if (!m_mainHandler->db()->removePpmTargetInformation(m_data.id()))
    return Core::FunctionReplyObject(m_data.id(), tr_lts("dds", "TargetInformation with id %1 can not be removed from DB")).arg(m_data.id());

  if (!m_mainHandler->dts()->removeTargetInformationByKey(m_data.id()))
    return Core::FunctionReplyObject(m_data.id(), tr_lts("dds", "TargetInformation with id %1 can not be removed from DDS")).arg(m_data.id());

  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return Core::FunctionReplyObject(m_data.id());
}


//------------------------------------------------------------------------------
void ObjectTargetInformation::onPublishData()
{
  TRACE_LOG(m_logger) << "Publish TargetInformation-data to dds (" << m_data.id() << ") ...";

  if (!m_mainHandler->dts()->publish(m_data))
    ERROR_LOG(m_logger) << "Error publishing TargetInformation-data to dds";
}

// -------------------------------------------------------------------------------------------------------
// convert methods
// -------------------------------------------------------------------------------------------------------

// ParticipantManagement::TargetInformation => Database::PpmTargetInformation
Database::PpmTargetInformation ObjectTargetInformation::toDbData(const TargetInformation &ddsData)
{
  Database::PpmTargetInformation dbData;

  dbData.id                   = ddsData.id();
  dbData.participantId        = ddsData.participantId();

  dbData.preWarningInterval          = ddsData.prewarningInterval();
  dbData.preWarningEffect            = static_cast<int>(ddsData.prewarningEffect().underlying());
  dbData.takeDownInterval            = ddsData.takedownInterval();
  dbData.takeDownEffect              = static_cast<int>(ddsData.takedownEffect().underlying());

  const std::vector<ParticipantManagement::ShootbackArea>& shootback_areas = ddsData.shootbackAreas();

  const QJsonObject &obj = toJson(shootback_areas);
  dbData.properties = QString::fromStdString( QJsonDocument(obj).toJson(QJsonDocument::Compact).toStdString() );

  return dbData;
}

// -------------------------------------------------------------------------------------------------------
// Database::PpmTargetInformation => ParticipantManagement::TargetInformation
TargetInformation ObjectTargetInformation::toDdsData(const Database::PpmTargetInformation &dbData)
{
  TargetInformation ddsData;

  ddsData.id(dbData.id);
  ddsData.participantId(dbData.participantId);

  ddsData.prewarningInterval(dbData.preWarningInterval);
  ddsData.prewarningEffect(static_cast<ProjectDataManagement::VulnerabilityState::inner_enum>(dbData.preWarningEffect));
  ddsData.takedownInterval(dbData.takeDownInterval);
  ddsData.takedownEffect(static_cast<ProjectDataManagement::VulnerabilityState::inner_enum>(dbData.takeDownEffect));

  const QByteArray &propertiesBa = dbData.properties.toUtf8();
  QJsonParseError parserError;
  const QJsonDocument doc(QJsonDocument::fromJson(propertiesBa, &parserError));

  if (parserError.error != QJsonParseError::NoError)
    qCritical() << "Error parsing json document: " << parserError.errorString() << " '" << propertiesBa << "'";

  qDebug() << "json to parse: " << doc.toJson();

  QJsonObject obj(doc.object());
  const std::vector<ShootbackArea> &sbAreas = vecfromJson(obj);
  ddsData.shootbackAreas(sbAreas);

  return ddsData;
}

// -------------------------------------------------------------------------------------------------------

} // Namespace ParticipantManagement