qt-migration-legatus/qt6-after/qt6-migrated-legatus/Lts/Services/ParticipantManagement/EquipmentEventHandling/equipment_event_handler.cpp

/**
  * The DeviceEventHandler class manages device events from TAB.
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Dassow Philipp, SLEA, 2017-09-04
  */

#include "equipment_event_handler.h"

#include "main_handler.h"
#include "ParticipantHandling/participant.h"

#include <QtCore/QTimer>
#include <LtsUtilsCore/dds_vector.h>

ParticipantManagement::EquipmentEventHandling::EquipmentEventHandler::EquipmentEventHandler(MainHandler *mainHandler, QObject *parent)
  : QObject(parent)
  , Interface::Fts::EquipmentSystemEventDataRequestHandler(mainHandler->fts())
  , m_mainHandler (mainHandler)
  , m_filterId(0)
  , m_logger(getLogger("EquipmentEventHandler"))
{
}

bool ParticipantManagement::EquipmentEventHandling::EquipmentEventHandler::init()
{
  if (!m_mainHandler->tabDtc()->enableEquipmentEvent())
  {
    ERROR_LOG (m_logger) << " TAB Dtc enableEquipmentEvent() failed !";
    return false;
  }

  if (!m_mainHandler->dts()->enableEquipmentSystemEventFtcReply())
  {
    ERROR_LOG (m_logger) << " Dts enableEquipmentSystemEventDataFtcReply() failed !";
    return false;
  }
  connect(m_mainHandler->tabDtc().get(), &TrainingAreaBase::Interface::Dtc::equipmentEventChanged, this, &EquipmentEventHandler::onEquipmentEventChanged);

  return true;
}

void ParticipantManagement::EquipmentEventHandling::EquipmentEventHandler::onEquipmentSystemEventDataRequest(const rti::core::SampleIdentity &cookie,
                                                                                                             const ParticipantManagement::EquipmentSystemEventDataRequest &request)
{
  INFO_LOG(m_logger) << "IN onEquipmentSystemEventDataRequest";

  Core::FunctionReplyObject ret;

  QString stmt = QStringLiteral(" SELECT rec_id, equipment_number, sample_time, position_lon, position_lat, position_z, equipment_function_id, sub_device_id,"
                               " unique_device_id, device_specific_event_code, event_data"
                               " FROM rec_equipment_system_event WHERE sample_time > ") + QString::number(request.startTime) + QStringLiteral(" AND "
                               " sample_time <= ") + QString::number(request.endTime);
  if (request.equipmentFunctionId > -1)
    stmt += QStringLiteral(" AND equipment_function_id=") + QString::number(request.equipmentFunctionId);
  if (request.subDeviceId > -1)
    stmt += QStringLiteral(" AND sub_device_id=") + QString::number(request.subDeviceId);
  if (request.deviceSpecificEventCode > -1)
    stmt += QStringLiteral(" AND device_specific_event_code=") + QString::number(request.deviceSpecificEventCode);

  INFO_LOG(m_logger) << "stmt: " << stmt;

  NSqlQuery q(m_mainHandler->db()->database());
  if (!q.exec(stmt))
  {
    ERROR_LOG(m_logger) << "Error while selecting event-data ";
    ERROR_LOG(m_logger) << "stmt : " << stmt;
    ret.setStr("Error while selecting data");
    m_mainHandler->fts()->equipmentSystemEventDataReply(cookie, ret);
    return;
  }

  // Unique FilterId for each requestEquipmentSystemEventFtcReply
  m_filterId++;
  ret.setId(m_filterId);

  QVector<qint64> keys;
  ParticipantManagement::EquipmentSystemEventFtcReply data;
  while (q.next())
  {
    int i = 0;

    // Unique Key with filterId important for removing from dds
    qint64 id = m_filterId;
    id <<= 32;
    id |= q.value(i++).toInt();
    keys += id;

    data.id = id;

    data.equipmentNumber = q.value(i++).toInt();
    data.timeStamp = q.value(i++).toLongLong();
    double pos_lon = q.value(i++).toDouble();
    double pos_lat = q.value(i++).toDouble();
    double pos_z = q.value(i++).toDouble();
    data.position = Core::GeoPosition(pos_lon, pos_lat, pos_z);
    data.equipmentFunctionId = q.value(i++).toInt();
    data.subDeviceId = q.value(i++).toInt();
    data.uniqueDeviceId = q.value(i++).toInt();
    data.deviceSpecificEventCode = q.value(i++).toInt();
    QByteArray evtData(q.value(i++).toByteArray());
    if (evtData.size() != 0)
      data.eventData = LtsUtils::convert<std::vector<uint8_t>>(evtData);
    data.filterId = m_filterId;

    m_mainHandler->dts()->publish(data);
  }

  QTimer::singleShot(5 * 60 * 1000, this, [keys, this](){ removeFromDDS(keys); });
  m_mainHandler->fts()->equipmentSystemEventDataReply(cookie, ret);
}

void ParticipantManagement::EquipmentEventHandling::EquipmentEventHandler::onEquipmentEventChanged(const TrainingAreaBase::EquipmentEvent &data, DataModification modType)
{
  if (modType != DataModification::eAdded && modType != DataModification::eModified)
    return;

  ParticipantManagement::EquipmentSystemEvent event;

  event.id = data.equipmentNumber;
  event.equipmentNumber = data.equipmentNumber;
  event.sampleTime = data.sampleTime;
  if (!std::isnan(event.position.lon) && !std::isnan(event.position.lat))
    event.position = Core::GeoPosition(data.position.lon, data.position.lat, 0.0);
  else
    event.position = m_mainHandler->participantHandler()->participantByEquipmentNumber(data.equipmentNumber)->position().pos;
  event.equipmentFunctionId = data.source.equipmentFunctionId;
  event.subDeviceId = data.source.subDeviceId;
  event.uniqueDeviceId = data.source.unqiueId;
  event.deviceSpecificEventCode = data.code;
  event.eventData = data.data;

  if (!m_mainHandler->dts()->publish(event))
  {
    ERROR_LOG(m_logger) << "Error publishing equipment event to dds from eqnr: " << event.equipmentNumber ;
  }
}

void ParticipantManagement::EquipmentEventHandling::EquipmentEventHandler::removeFromDDS(const QVector<qint64> &keys)
{
  for (qint64 key : keys)
    m_mainHandler->dts()->removeEquipmentSystemEventFtcReplyByKey(key);
}