Initial commit

This commit is contained in:
torsten committed 2026-08-13 18:33:10 +02:00
commit b7d90b9afe
16245 files changed
+3396666

No files matched your search

@@ -0,0 +1,444 @@
/**
* The UasHandler class manages all Uas related function topics and holds classes for
* further Uas data.
* $Id$
* $HeadURL$
* $Author$
* Created by Steve Kemayou, ESZS, 2025-06-02
*/
#include <ngldb/db_service_handler.h>
#include <ngldb/dbtransaction.h>
#include "main_handler.h"
#include "ParticipantHandling/participant.h"
#include "mission_plan_handler.h"
namespace ParticipantManagement
{
namespace UasHandling
{
MissionPlanHandler::MissionPlanHandler(MainHandler *mainHandler)
: Interface::Fts::ModifyMissionPlanRequestHandler(mainHandler->fts())
, Interface::Fts::RemoveMissionPlanRequestHandler(mainHandler->fts())
, Interface::Fts::SetMissionActionFulfilledRequestHandler(mainHandler->fts())
, m_mainHandler(mainHandler)
, m_logger(getLogger("MissionPlanHandler"))
{
}
ParticipantManagement::UasHandling::MissionPlanHandler::~MissionPlanHandler()
{
qDeleteAll(m_objMissionPlans);
}
bool MissionPlanHandler::init()
{
DEBUG_LOG(m_logger)<<" -- MissionPlanHandler init...";
qDeleteAll(m_objMissionPlans);
m_objMissionPlans.clear();
if (!loadMissionPlansFromDb())
return false;
return true;
}
void MissionPlanHandler::onModifyMissionPlanRequest(const rti::core::SampleIdentity &cookie, const ModifyMissionPlanRequest &request)
{
Core::FunctionReplyObject reply = request.id() == 0 ? createMissionPlanRequest(request)
: modifyMissionPlanRequest(request);
m_mainHandler->fts()->modifyMissionPlanReply(cookie, reply);
}
void MissionPlanHandler::onRemoveMissionPlanRequest(const rti::core::SampleIdentity &cookie, const RemoveMissionPlanRequest &request)
{
Core::FunctionReplyObject reply = removeMissionPlanRequest(request.id());
m_mainHandler->ddsHandler()->fts()->removeMissionPlanReply(cookie, reply);
}
void MissionPlanHandler::onSetMissionActionFulfilledRequest(const rti::core::SampleIdentity &cookie, const SetMissionActionFulfilledRequest &request)
{
//DEBUG_LOG(m_logger)<<">> -- onSetMissionActionFulfilledRequest -- ";
Core::FunctionReplyObject reply = setMissionActionFulfilledRequest(request);
m_mainHandler->ddsHandler()->fts()->setMissionActionFulfilledReply(cookie, reply);
}
bool MissionPlanHandler::loadMissionPlansFromDb()
{
QVector<ParticipantManagement::Database::PpmMissionPlan> missionPlanVec;
QVector<ParticipantManagement::Database::PpmMissionItem> missionItemVec;
QVector<ParticipantManagement::Database::PpmMissionAction> missionActionVec;
if (!m_mainHandler->db()->select(missionActionVec))
{
ERROR_LOG(m_logger)<<"Error reading data from database >> PpmMissionAction: "<<missionActionVec.size();
return false;
}
if (!m_mainHandler->db()->select(missionItemVec))
{
ERROR_LOG(m_logger)<<"Error reading data from database >> missionItemVec"<<missionItemVec.size();
return false;
}
if (!m_mainHandler->db()->select(missionPlanVec))
{
ERROR_LOG(m_logger)<<"Error reading data from database >> missionPlanVec"<<missionPlanVec.size();
return false;
}
DEBUG_LOG(m_logger) << "load MissionPlans From Db Plans size = " << missionPlanVec.size()
<<" Items size = "<<missionItemVec.size()
<<" Actions size = "<<missionActionVec.size();
// add to internal buffer
for (const ParticipantManagement::Database::PpmMissionPlan &data : qAsConst(missionPlanVec))
{
ParticipantManagement::MissionPlan missionPlan;
missionPlan.id(data.id);
missionPlan.name(data.name.toStdString());
missionPlan.participantId(data.participantId);
missionPlan.missionStart(data.missionStart.toMSecsSinceEpoch());
missionPlan.repeat(data.repeat);
missionPlan.jumpToStart(data.jumpToStart);
QMap <int, ParticipantManagement::Database::PpmMissionItem> itemsDbMap; // QMap to get it sorted
QMultiMap <int, ParticipantManagement::Database::PpmMissionAction> actionsDbMap;
//get mission items and actions for curr mission plan id
for (const ParticipantManagement::Database::PpmMissionItem &itemDb : qAsConst(missionItemVec))
{
if (itemDb.missionPlanId == data.id)
{
itemsDbMap.insert(itemDb.elementNumber, itemDb);
for (const ParticipantManagement::Database::PpmMissionAction &actionDb : qAsConst(missionActionVec) )
{
if (actionDb.missionItemId == itemDb.id)
actionsDbMap.insert(actionDb.missionItemId, actionDb);
}
}
}
missionPlan.items().reserve(itemsDbMap.size());
for (const ParticipantManagement::Database::PpmMissionItem &item : qAsConst(itemsDbMap))
{
ParticipantManagement::MissionItem msi;
msi.actions().reserve(actionsDbMap.size());
msi.name(item.name.toStdString());
msi.location(Core::GeoPosition(item.location.x(), item.location.y(), item.location.z()));
msi.itemNumber(item.elementNumber);
int actionsFulfilled = 0;
int64_t latestFulfilled = 0;
for (const auto &action : actionsDbMap)
{
if (action.missionItemId == item.id)
{
ParticipantManagement::MissionAction msa;
msa.planId(missionPlan.id());
msa.actionType(action.missionActionTypeId);
msa.duration(action.duration);
msa.fulfilled(action.fulfilled.toMSecsSinceEpoch());
msa.properties(action.properties.toStdString());
msa.name(action.name.toStdString());
msa.actionNumber(action.elementNumber);
msa.itemNumber(msi.itemNumber());
msi.actions().push_back(msa);
if (msa.fulfilled() > 0)
actionsFulfilled++;
if (latestFulfilled < msa.fulfilled())
latestFulfilled = msa.fulfilled();
}
}
msi.actionsFulfilled(actionsFulfilled);
msi.fulfilled(latestFulfilled);
missionPlan.items().push_back(msi);
}
setLatestFulfilledItem(missionPlan); // update mission plan fulfillment count & fulfillemnt latest time
ObjectMissionPlan *obj = new ObjectMissionPlan(m_mainHandler->ddsHandler(), m_mainHandler->db(), missionPlan);
obj->setDbMissionItems(itemsDbMap, actionsDbMap);
m_objMissionPlans.insert(missionPlan.id(), obj);
// publish mission plan data
m_mainHandler->ddsHandler()->dts()->publish(missionPlan);
}
DEBUG_LOG(m_logger)<<" -- END load mission plan From Db -- ";
return true;
}
bool MissionPlanHandler::isUasInAutoMode(int participantId)
{
m_mainHandler->ddsHandler()->dtc()->waitForHistoricalDataUAS(3000);
const auto uas = m_mainHandler->ddsHandler()->dtc()->getUasByParticipantId(participantId, m_mainHandler->exerciseId());
if (uas.id() < 1)
{
ERROR_LOG(m_logger) << "no uas for pid " << participantId;
return false;
}
DEBUG_LOG(m_logger) << "uas with pid " << participantId << " is in mode: " << (int)uas.uasState().underlying();
return (uas.uasState() == ProjectDataManagement::UasState::Auto);
}
// stolen from Lts/Plugins/ParticipantManagement/Gui/ParticipantInfo/participant_info_dialog.cpp
bool MissionPlanHandler::isUasCombatReady(int participantId)
{
m_mainHandler->ddsHandler()->dtc()->waitForHistoricalDataDynamicParticipantData(3000);
const auto data = m_mainHandler->ddsHandler()->dtc()->dynamicParticipantData(participantId);
if (data.participantId() == 0)
{
return false;
}
//Current State
if (data.stateHistory().empty())
{
return false;
}
const auto &history = data.stateHistory();
//LasState is the last "real" state, that has a VBG <=8 (Castastrophic)
//It's not the last state received, as there can be other state changes like Sanitation, or NearMiss
auto lastState = m_mainHandler->ddsHandler()->dtc()->youngestStateInformation(history/*, true*/ /* debug */);
decltype(lastState) youngestState;
youngestState.stateTime(0);
for (const auto &si : history)
{
DEBUG_LOG(m_logger) << "StateInformation "
<< " time=" << si.stateTime()
<< " vulnerabilityBits=" << si.vulnerabilityBits()
<< " vulnerabilityKindId=" << si.vulnerabilityKindId();
if (youngestState.stateTime() < si.stateTime())
youngestState = si;
}
return (youngestState.vulnerabilityState() == ProjectDataManagement::VulnerabilityState::CombatReady);
}
Core::FunctionReplyObject MissionPlanHandler::createMissionPlanRequest(const ModifyMissionPlanRequest &request)
{
DEBUG_LOG(m_logger) <<" >> -- createMissionPlanRequest -- ";
if (request.participantId() > 0 && !isUasParticipant(request.participantId()))
{
return Core::FunctionReplyObject(tr_lts("dds", "Participant with id %1 is not a Uas participant.")).arg(request.participantId());
}
if (!isUasInAutoMode(request.participantId()))
{
return Core::FunctionReplyObject(tr_lts("dds", "Uas with participant id %1 is not in auto mode - maybe the safety tablet is currently engaged.")).arg(request.participantId());
}
if (!isUasCombatReady(request.participantId()))
{
return Core::FunctionReplyObject(tr_lts("dds", "Uas with participant id %1 ------ not combat ready.")).arg(request.participantId());
}
/// 1- insert in DB Mission plan
/// 2- insert in DB Mission Items
/// 3- insert in DB Mission Actions
//1-) insert mission plan
Database::PpmMissionPlan dbMissionPlan = ObjectMissionPlan::toDbMissionPlan(request);
const MissionPlan missionPlan = ObjectMissionPlan::fillMissionPlanData(request);
ObjectMissionPlan *obj = new ObjectMissionPlan(m_mainHandler->ddsHandler(), m_mainHandler->db(), missionPlan);
Core::FunctionReplyObject ret = obj->createMissionPlan(dbMissionPlan, request.items());
if (ret.error())
{
delete obj;
return ret;
}
m_objMissionPlans.insert(obj->id(), obj);
publishMissionPlan(obj->getMissionPlanData()); // publish mission plan
return Core::FunctionReplyObject(dbMissionPlan.id);
}
Core::FunctionReplyObject MissionPlanHandler::modifyMissionPlanRequest(const ModifyMissionPlanRequest &request)
{
DEBUG_LOG(m_logger)<<" >> -- modifyMissionPlanRequest -- ";
/// 1- update Mission plan Table
/// 2- remove first all mission items and their actions
/// 3- add New mission items
/// 4- add new mission actions
ObjectMissionPlan *obj = m_objMissionPlans.value(request.id());
if (!obj || request.id() < 0)
return Core::FunctionReplyObject(request.id(), tr_lts("dds", "Couldn't remove Mission plan with id %1")).arg(request.id());
const Database::PpmMissionPlan &dbMissionPlan = ObjectMissionPlan::toDbMissionPlan(request);
auto ret = obj->updateMissionPlan(dbMissionPlan, request.items());
publishMissionPlan(obj->getMissionPlanData()); // publish mission plan
return ret;
}
Core::FunctionReplyObject MissionPlanHandler::removeMissionPlanRequest(int id)
{
DEBUG_LOG(m_logger)<<" >> -- removeMissionPlanRequest -- ";
Core::FunctionReplyObject ret;
ObjectMissionPlan *obj = m_objMissionPlans.value(id, nullptr);
if (!obj)
return ret;
ret = obj->removeMissionPlan(id);
if (ret.error())
return ret;
delete obj;
m_objMissionPlans.remove(id);
m_mainHandler->ddsHandler()->dts()->removeMissionPlanByKey(id);
return ret;
}
bool MissionPlanHandler::setCurrentMissionActionFulfilled(int participantId, const QString &nameOfTheMissionThatEnded)
{
// okay we somehow need to find the currently running mission for this participant..... the plan: filter mission plans by participant und by (start < now)
bool found = false;
for (const auto &missionPlan : m_objMissionPlans.values())
{
if (missionPlan->missionPlan().participantId() == participantId && missionPlan->missionPlan().missionStart() <= m_mainHandler->currentTimeMSec())
{
// get current action (stolen from Services/CentralEffectSimulation/Plugins/MissionPlan/ces_mission_plan_object.cpp)
const std::vector< ParticipantManagement::MissionItem > items = missionPlan->missionPlan().items(); // copy !!
for (const auto &item : items)
{
for (auto &msa : item.actions())
{
const QString thisMissionName(QStringLiteral("%1_%2_%3").arg(missionPlan->missionPlan().id()).arg(QString::fromStdString(missionPlan->missionPlan().name()), QString::fromStdString(item.name())));
INFO_LOG(m_logger) << ">> mission item: this mission name: " << thisMissionName << ", fulfilled: " << msa.fulfilled();
if (msa.fulfilled() > 0)
{
continue;
}
if (thisMissionName != nameOfTheMissionThatEnded)
{
continue;
}
DEBUG_LOG(m_logger) << ">> ######### setMissionActionFulfilledRequest !!! item = " << item.itemNumber() << ", name = " << item.name() << ", missionPlan = " << missionPlan->missionPlan().id();
SetMissionActionFulfilledRequest req;
req.actionNumber(msa.actionNumber());
req.fulfilled(true);
req.missionId(missionPlan->missionPlan().id());
req.itemNumber(item.itemNumber());
const auto res = setMissionActionFulfilledRequest(req);
if (res.error())
{
ERROR_LOG(m_logger) << "failed to set current mission action as fulfilled: " << res.str();
}
found = true;
break;
}
if (found)
{
break;
}
}
if (found)
{
break;
}
}
}
if (found)
{
return true;
}
// maybe okay? last mission action was already fulfilled? is this even possible at this point?
DEBUG_LOG(m_logger) << "failed to set current mission action as fulfilled: no action found for pId " << participantId;
return false;
}
Core::FunctionReplyObject MissionPlanHandler::setMissionActionFulfilledRequest(const SetMissionActionFulfilledRequest &request)
{
DEBUG_LOG(m_logger)<<" -- [setMissionActionFulfilledRequest] req.missionId: "<<request.missionId();
Core::FunctionReplyObject ret;
ObjectMissionPlan *obj = m_objMissionPlans.value(request.missionId(), nullptr);
if (!obj)
return ret;
ret = obj->setMissionActionFulfilled(request, m_mainHandler->currentTimeMSec());
m_mainHandler->ddsHandler()->dts()->publish(obj->missionPlan());
return ret;
}
void MissionPlanHandler::publishMissionPlan(const MissionPlan &missionplan)
{
m_mainHandler->ddsHandler()->dts()->publish(missionplan);
}
bool MissionPlanHandler::isUasParticipant(int participantId) const
{
const ParticipantManagement::ParticipantHandling::Participant *PARTICIPANT = m_mainHandler->participantHandler()->participantById(participantId);
if (PARTICIPANT == nullptr)
{
WARNING_LOG(m_logger) << "Got invalid participantId " << participantId;
return false;
}
const int TYPE_ID = PARTICIPANT->typeId();
return m_mainHandler->ddsHandler()->dtc()->isTypeUas(TYPE_ID);
}
int MissionPlanHandler::getNumberOfActionFulfilled(const MissionItem &msi) const
{
int count = 0;
for (auto action : msi.actions())
{
if (action.fulfilled() > 0)
count++;
}
return count;
}
void MissionPlanHandler::setLatestFulfilledItem(MissionPlan &missionPlan)
{
int count = 0;
int64_t latestTime = 0;
for (auto item : missionPlan.items())
{
if (item.actionsFulfilled() > 0)
count++;
if (latestTime < item.fulfilled())
latestTime = item.fulfilled();
missionPlan.itemsFulfilled(count);
missionPlan.fulfilled(latestTime);
}
}
int64_t MissionPlanHandler::getLastestFulfilledAction(const MissionItem &msi) const
{
int64_t latestTime = 0;
for (auto action : msi.actions())
{
if (action.fulfilled() > latestTime)
latestTime = action.fulfilled();
}
return latestTime;
}
}// namespace UasHandling
}
@@ -0,0 +1,64 @@
/**
* The UasHandler class manages all Uas related function topics and holds classes for
* further Uas data.
* $Id$
* $HeadURL$
* $Author$
* Created by Steve Kemayou, ESZS, 2025-06-02
*/
#pragma once
#include <QtCore/QHash>
#include <ParticipantManagement/ppm_fts.h>
#include <ParticipantManagement/ppm_ftc.h>
#include <CentralEffectSimulation/dds_handler.h>
#include "object_mission_plan.h"
#include "logger.h"
namespace ParticipantManagement
{
class ObjectMissionPlan;
class MainHandler;
namespace UasHandling
{
class MissionPlanHandler final
: protected Interface::Fts::ModifyMissionPlanRequestHandler
, protected Interface::Fts::RemoveMissionPlanRequestHandler
, protected Interface::Fts::SetMissionActionFulfilledRequestHandler
{
public:
explicit MissionPlanHandler(MainHandler *mainHandler);
~MissionPlanHandler();
bool init();
void onModifyMissionPlanRequest(const rti::core::SampleIdentity &cookie, const ModifyMissionPlanRequest &request) override final;
void onRemoveMissionPlanRequest(const rti::core::SampleIdentity &cookie, const RemoveMissionPlanRequest &request) override final;
void onSetMissionActionFulfilledRequest(const rti::core::SampleIdentity &cookie, const SetMissionActionFulfilledRequest &request) override final;
bool loadMissionPlansFromDb();
bool setCurrentMissionActionFulfilled(int participantId, const QString &nameOfTheMissionThatEnded);
private:
bool isUasCombatReady(int participantId);
bool isUasInAutoMode(int participantId);
Core::FunctionReplyObject createMissionPlanRequest(const ModifyMissionPlanRequest &request);
Core::FunctionReplyObject modifyMissionPlanRequest(const ModifyMissionPlanRequest &request);
Core::FunctionReplyObject removeMissionPlanRequest(int id);
Core::FunctionReplyObject setMissionActionFulfilledRequest(const SetMissionActionFulfilledRequest &request);
void publishMissionPlan(const MissionPlan &missionplan);
bool isUasParticipant(int participantId) const;
int getNumberOfActionFulfilled(const MissionItem &msi) const;
void setLatestFulfilledItem(MissionPlan &missionPlan); /// update mission plan fulfillment count & fulfillemnt latest time
int64_t getLastestFulfilledAction(const MissionItem &msi) const;
MainHandler *m_mainHandler;
QHash<int32_t, ObjectMissionPlan *> m_objMissionPlans;
LOGGER_T m_logger;
};
}
}// namespace ParticipantManagement
@@ -0,0 +1,398 @@
/**
* The ObjectMissionPlan class represents a ObjectMissionPlan. It holds the data and offers some conversion methods.
* $Id$
* $HeadURL$
* $Author$
* Created by Steve Kemayou, ESZS, 2025-04-08
*/
#include "object_mission_plan.h"
#include <ngldb/dbtransaction.h>
namespace ParticipantManagement
{
namespace UasHandling
{
ObjectMissionPlan::ObjectMissionPlan(const std::shared_ptr<DdsHandler> &ddsHandler,
const std::shared_ptr<DatabaseInterface> &db,
const ParticipantManagement::MissionPlan & missionPlan,
QObject *parent)
: QObject(parent)
, m_ddsHandler(ddsHandler)
, m_db(db)
, m_missionplan(missionPlan)
, m_logger(getLogger("ObjectMissionPlan"))
{
DEBUG_LOG(m_logger)<<" - ctor ObjectMissionPlan: planId: "<<m_missionplan.id();
}
int32_t ObjectMissionPlan::id() const
{
return m_missionplan.id();
}
int32_t ObjectMissionPlan::participantId() const
{
return m_missionplan.participantId();
}
Database::PpmMissionPlan ObjectMissionPlan::toDbMissionPlan(const ModifyMissionPlanRequest &mp)
{
Database::PpmMissionPlan result;
result.id = mp.id();
result.name = QString::fromStdString(mp.name());
result.missionStart = QDateTime::fromMSecsSinceEpoch(mp.missionStart());
result.repeat = mp.repeat();
result.jumpToStart = mp.jumpToStart();
result.participantId = mp.participantId();
return result;
}
MissionPlan ObjectMissionPlan::fillMissionPlanData(const ModifyMissionPlanRequest &in)
{
MissionPlan out;
out.id(in.id());
out.name(in.name());
out.missionStart(in.missionStart());
out.properties(in.properties());
out.items(in.items());
out.participantId(in.participantId());
out.jumpToStart(in.jumpToStart());
out.repeat(in.repeat());
return out;
}
MissionPlan ObjectMissionPlan::getMissionPlanData() const
{
return m_missionplan;
}
void ObjectMissionPlan::setDbMissionItems(const QMap<int, ParticipantManagement::Database::PpmMissionItem> &dbItems,
const QMap<int, Database::PpmMissionAction> &dbActions)
{
m_mapMissionItems.clear();
m_dbMissionActions.clear();
for (const ParticipantManagement::Database::PpmMissionItem &item : qAsConst(dbItems))
{
ParticipantManagement::MissionItem msi;
msi.actions().reserve(dbActions.size());
msi.name(item.name.toStdString());
msi.location(Core::GeoPosition(item.location.x(), item.location.y(), item.location.z()));
msi.itemNumber(item.elementNumber);
std::vector<Database::PpmMissionAction> actionsVec;
for (const auto &action : dbActions)
{
if (action.missionItemId == item.id)
{
ParticipantManagement::MissionAction msa;
msa.actionType(action.missionActionTypeId);
msa.duration(action.duration);
msa.fulfilled(action.fulfilled.toMSecsSinceEpoch());
msa.properties(action.properties.toStdString());
msa.name(action.name.toStdString());
msa.actionNumber(action.elementNumber);
msa.planId(item.missionPlanId);
msi.actions().push_back(msa);
actionsVec.push_back(action);
}
}
m_mapMissionItems.insert(item.id, msi);
m_dbMissionActions.push_back(actionsVec);
}
}
const MissionPlan &ObjectMissionPlan::missionPlan() const
{
return m_missionplan;
}
Core::FunctionReplyObject ObjectMissionPlan::createMissionPlan(Database::PpmMissionPlan newMissionPlan, const std::vector<MissionItem> &missionItems)
{
/// 1- insert in DB Mission plan
/// 2- insert in DB Mission Items
/// 3- insert in DB Mission Actions
DBTransaction trans(m_db->database());
newMissionPlan.aborted = false;
if (!m_db->insert(newMissionPlan))
{
QString error = QStringLiteral("Could not insert mission plan into database");
ERROR_LOG(m_logger)<< error;
return Core::FunctionReplyObject(error.toStdString().c_str());
}
std::vector<MissionItem> itemVec = missionItems;
m_mapMissionItems.clear();
m_mapMissionItems.reserve(itemVec.size());
std::vector<std::vector<Database::PpmMissionAction>>itemsVec;
m_dbMissionActions.clear();
for ( auto &item : itemVec)
{
Database::PpmMissionItem dbItem;
dbItem.missionPlanId = newMissionPlan.id;
dbItem.name = QString::fromStdString(item.name());
dbItem.elementNumber = item.itemNumber();
dbItem.location = LtsUtils::QPoint3D(item.location().lon(),item.location().lat(), item.location().z());
if (!m_db->insert(dbItem))
return Core::FunctionReplyObject(0, tr_lts("dds", "Error adding 'Mission Item' to database"));
std::vector<Database::PpmMissionAction> actionsVec;
actionsVec.reserve(item.actions().size());
for (auto &action : item.actions())
{
action.planId(newMissionPlan.id);
Database::PpmMissionAction dbAction;
dbAction.missionActionTypeId = action.actionType();
dbAction.missionItemId = dbItem.id;
dbAction.duration = action.duration();
dbAction.name = QString::fromStdString(action.name());
dbAction.properties = QString::fromStdString(action.properties());
dbAction.fulfilled = QDateTime::fromMSecsSinceEpoch(action.fulfilled());
dbAction.elementNumber = action.actionNumber();
if (!m_db->insert(dbAction))
return Core::FunctionReplyObject(0, tr_lts("dds", "Error adding 'Mission Action' to database"));
actionsVec.push_back(dbAction);
}//loop mission actions
m_mapMissionItems.insert(dbItem.id, item);
m_dbMissionActions.push_back(actionsVec); // [elNumber][actionNumber]
}//loop mission items
m_missionplan.id(newMissionPlan.id);
m_missionplan.name(newMissionPlan.name.toStdString());
m_missionplan.missionStart(newMissionPlan.missionStart.toMSecsSinceEpoch());
m_missionplan.participantId(newMissionPlan.participantId);
m_missionplan.jumpToStart(newMissionPlan.jumpToStart);
m_missionplan.repeat(newMissionPlan.repeat);
m_missionplan.items(itemVec);
m_missionplan.fulfilled(0);
m_missionplan.itemsFulfilled(0);
for (auto &item : m_missionplan.items())
{
for (auto &action : item.actions())
DEBUG_LOG(m_logger)<<"[CREATE] itemIdx: "<<item.itemNumber()
<<" act.Num: "<<action.actionNumber()<<" act.ItemNum: "<<action.itemNumber()<<" itemFul:"<<action.fulfilled();
}
trans.commit();
DEBUG_LOG(m_logger)<< ">> [NEW] mission plan with id( "<<newMissionPlan.id<<" ) inserted !!";
return Core::FunctionReplyObject(newMissionPlan.id);
}
Core::FunctionReplyObject ObjectMissionPlan::updateMissionPlan(Database::PpmMissionPlan newMissionPlan, const std::vector<MissionItem> &missionItems)
{
if (missionItems.size() == 0)
return Core::FunctionReplyObject(newMissionPlan.id, tr_lts("dds", "Could not modify MissionPlan without segments."));
/// 1- update missipn plan table
/// 2- remove items and their actions
/// 3- insert new items and their actions
DBTransaction trans(m_db->database());
const auto tmpDbMissionItems = m_mapMissionItems;
newMissionPlan.aborted = false;
/// update mission plan table
if (!m_db->update(newMissionPlan))
{
QString error = QStringLiteral("Could not update mission plan! ");
ERROR_LOG(m_logger)<< error;
return Core::FunctionReplyObject(error.toStdString().c_str());
}
/// remove all items and their actions from the database
for (const auto &itemId : tmpDbMissionItems.keys())
{
if (!m_db->removePpmMissionItem(itemId))
{
QString error = QStringLiteral("Could not remove mission plan from database");
ERROR_LOG(m_logger)<< error;
return Core::FunctionReplyObject(0, tr_lts("dds", "Could not update mission plan into!"));
}
}
/// insert new items with their actions in the data base;
m_mapMissionItems.clear();
m_mapMissionItems.reserve(missionItems.size());
m_dbMissionActions.clear();
std::vector<MissionItem> itemVec = missionItems;
for (auto &item : itemVec)
{
Database::PpmMissionItem dbItem;
dbItem.missionPlanId = newMissionPlan.id;
dbItem.name = QString::fromStdString(item.name());
dbItem.elementNumber = item.itemNumber();
dbItem.location = LtsUtils::QPoint3D(item.location().lon(),item.location().lat(), item.location().z());
if (!m_db->insert(dbItem))
return Core::FunctionReplyObject(0, tr_lts("dds", "Error adding 'Mission Item' to database"));
std::vector<Database::PpmMissionAction> actionsVec;
actionsVec.reserve(item.actions().size());
for (auto &action : item.actions())
{
action.planId(newMissionPlan.id);
Database::PpmMissionAction dbAction;
dbAction.missionActionTypeId = action.actionType();
dbAction.missionItemId = dbItem.id;
dbAction.duration = action.duration();
dbAction.name = QString::fromStdString(action.name());
dbAction.properties = QString::fromStdString(action.properties());
dbAction.fulfilled = QDateTime::fromMSecsSinceEpoch(action.fulfilled());
dbAction.elementNumber = action.actionNumber();
if (!m_db->insert(dbAction))
return Core::FunctionReplyObject(0, tr_lts("dds", "Error adding 'Mission Action' to database"));
actionsVec.push_back(dbAction);
}//loop mission actions
m_mapMissionItems.insert(dbItem.id, item);
m_dbMissionActions.push_back(actionsVec); // [elNumber][actionNumber]
}//loop mission items
trans.commit();
m_missionplan.id(newMissionPlan.id);
m_missionplan.name(newMissionPlan.name.toStdString());
m_missionplan.missionStart(newMissionPlan.missionStart.toMSecsSinceEpoch());
m_missionplan.participantId(newMissionPlan.participantId);
m_missionplan.jumpToStart(newMissionPlan.jumpToStart);
m_missionplan.repeat(newMissionPlan.repeat);
m_missionplan.items(itemVec);
m_missionplan.itemsFulfilled(0); // on update items and action entries will be cleared
m_missionplan.fulfilled(0);
DEBUG_LOG(m_logger)<< ">> [UPDATE] mission plan with id( "<<m_missionplan.id()<<" ) Updated !!";
return Core::FunctionReplyObject(m_missionplan.id());
}
Core::FunctionReplyObject ObjectMissionPlan::removeMissionPlan(int id)
{
DBTransaction trans(m_db->database());
if (!m_db->removePpmMissionPlan(id))
{
QString error = QStringLiteral("Could not remove mission plan ! ");
ERROR_LOG(m_logger)<< error;
return Core::FunctionReplyObject(error.toStdString().c_str());
}
trans.commit();
m_dbMissionActions.clear();
m_mapMissionItems.clear();
DEBUG_LOG(m_logger)<< ">> [REMOVE] mission Action with id( "<<id<<" ) deleted !!";
return Core::FunctionReplyObject();
}
Core::FunctionReplyObject ObjectMissionPlan::setMissionActionFulfilled(SetMissionActionFulfilledRequest req, qint64 currentTimeMSec)
{
//0- if actionNumb and itemNumb are -1 -> missionplan is aborted. only update missionPlan table with status aborted = true
//1- get db mission action from actionNumber
//2- set mission action as fulfilled
//3- set mission action save in db
//4- update cache data
if (!m_db)
{
ERROR_LOG(m_logger) << "no init yet....";
return Core::FunctionReplyObject("");
}
if (req.missionId() != m_missionplan.id())
{
QString error = QStringLiteral("Wrong missionPlan Object caught Request: %1 / currPlanId: %2").arg(req.missionId()).arg(m_missionplan.id());
ERROR_LOG(m_logger)<< error;
return Core::FunctionReplyObject(error.toStdString().c_str());
}
// Abort in case itemNumb=-1 && actionNumb=-1
if (req.actionNumber() < 0 && req.itemNumber() < 0)
{
m_missionplan.aborted(true);
return setMissionPlanAborted(true);
}
auto &dbActions = m_dbMissionActions[req.itemNumber()]; //[elemNum][actionNum]
if (dbActions.empty()
|| req.actionNumber() >= static_cast<int>(dbActions.size())
|| req.actionNumber() < 0
|| req.itemNumber() < 0) // actionNumber start by 0
{
QString error = QStringLiteral("Could not set mission action with id: %1 ! ").arg(req.actionNumber());
ERROR_LOG(m_logger)<< error;
return Core::FunctionReplyObject(error.toStdString().c_str());
}
Database::PpmMissionAction &dbAction = dbActions[req.actionNumber()];
dbAction.fulfilled = QDateTime::fromMSecsSinceEpoch(currentTimeMSec);
if (!m_db->update(dbAction))
{
QString error = QStringLiteral("Could not update mission action! ");
ERROR_LOG(m_logger)<< error;
return Core::FunctionReplyObject(error.toStdString().c_str());
}
//update item in case actions fulfilled
//1- actions count
//2- number of actions fulfilled
//3- check if action count == item.actions.size()
//4- if yes update missioPlan & missionItem fulfilled
MissionItem &msi = m_mapMissionItems[dbAction.missionItemId];
msi.fulfilled(dbAction.fulfilled.toMSecsSinceEpoch());
msi.actionsFulfilled(msi.actionsFulfilled() + 1);
MissionAction &msa = m_mapMissionItems[dbAction.missionItemId].actions()[dbAction.elementNumber];
msa.fulfilled(dbAction.fulfilled.toMSecsSinceEpoch());
m_missionplan.items()[req.itemNumber()] = m_mapMissionItems[dbAction.missionItemId]; // item in MissionPlan updated through elementNumber
/// update fulfilled time for items and mission plan
/// update fulfilled items count
int numbItemFulfilled = 0;
for(const auto &item : m_mapMissionItems)
{
if (item.actionsFulfilled() == static_cast<int>(item.actions().size()))
numbItemFulfilled++;
}
m_missionplan.itemsFulfilled(numbItemFulfilled);
m_missionplan.fulfilled(dbAction.fulfilled.toMSecsSinceEpoch());
return Core::FunctionReplyObject(m_missionplan.id());
}
Core::FunctionReplyObject ObjectMissionPlan::setMissionPlanAborted(bool state)
{
DEBUG_LOG(m_logger)<<" -- [setMissionPlanAborted] abort mission plan: "<<m_missionplan.id();
Database::PpmMissionPlan dbMissionPlan;
// m_db->selectPpmMissionPlan(m_missionplan.id(),dbMissionPlan);
dbMissionPlan.missionStart = QDateTime::fromMSecsSinceEpoch(m_missionplan.missionStart());
dbMissionPlan.jumpToStart = m_missionplan.jumpToStart();
dbMissionPlan.id = m_missionplan.id();
dbMissionPlan.name = QString::fromStdString(m_missionplan.name());
dbMissionPlan.participantId = m_missionplan.participantId();
dbMissionPlan.repeat = m_missionplan.repeat();
dbMissionPlan.aborted = state;
/// update mission plan table
if (!m_db->update(dbMissionPlan))
{
QString error = QStringLiteral("Could not update mission plan! ");
ERROR_LOG(m_logger)<< error;
return Core::FunctionReplyObject(error.toStdString().c_str());
}
return Core::FunctionReplyObject(m_missionplan.id());
}
} // namespace UasHandling
} // namespace ParticipantManagement
@@ -0,0 +1,60 @@
/**
* The ObjectMissionPlan class represents a ObjectMissionPlan. It holds the data and offers some conversion methods.
* $Id$
* $HeadURL$
* $Author$
* Created by Steve Kemayou, ESZS, 2025-04-08
*/
#pragma once
#include <ParticipantManagement/ppm_db.h>
#include <ParticipantManagement/ppm_dtc.h>
#include <ParticipantManagement/logger.h>
#include <ParticipantManagement/dds_handler.h>
#include "logger.h"
#include <QObject>
namespace ParticipantManagement
{
namespace UasHandling
{
class ObjectMissionPlan : public QObject
{
Q_OBJECT
public:
explicit ObjectMissionPlan(const std::shared_ptr<ParticipantManagement::DdsHandler> &ddsHandler,
const std::shared_ptr<ParticipantManagement::DatabaseInterface> &db,
const ParticipantManagement::MissionPlan &missionPlan,
QObject *parent = nullptr);
int32_t id() const;
int32_t participantId() const;
static Database::PpmMissionPlan toDbMissionPlan(const ParticipantManagement::ModifyMissionPlanRequest &mp);
static MissionPlan fillMissionPlanData(const ModifyMissionPlanRequest &in);
MissionPlan getMissionPlanData() const;
void setDbMissionItems( const QMap <int, ParticipantManagement::Database::PpmMissionItem> &dbItems,
const QMap <int, ParticipantManagement::Database::PpmMissionAction> &dbActions);
const ParticipantManagement::MissionPlan &missionPlan() const;
Core::FunctionReplyObject createMissionPlan(Database::PpmMissionPlan newMissionPlan, const std::vector<MissionItem> &missionItems);
Core::FunctionReplyObject updateMissionPlan(Database::PpmMissionPlan newMissionPlan, const std::vector<MissionItem> &missionItems);
Core::FunctionReplyObject removeMissionPlan(int id);
Core::FunctionReplyObject setMissionActionFulfilled(SetMissionActionFulfilledRequest req, qint64 currentTimeMSec);
Core::FunctionReplyObject setMissionPlanAborted(bool state);
private:
std::shared_ptr<ParticipantManagement::DdsHandler> m_ddsHandler;
std::shared_ptr<ParticipantManagement::DatabaseInterface> m_db;
ParticipantManagement::MissionPlan m_missionplan;
QHash<int /*dbItemId*/, ParticipantManagement::MissionItem > m_mapMissionItems; /// key:dbItemId | Value MissionItem
std::vector<std::vector<ParticipantManagement::Database::PpmMissionAction> > m_dbMissionActions; /// [ItemNumber][ActionNumber]
LOGGER_T m_logger;
};
} // namespace UasHandling
} // namespace ParticipantManagement
+91
View File
@@ -0,0 +1,91 @@
/**
* The Uas class represents a Uas. It holds the data and offers some conversion methods.
* $Id$
* $HeadURL$
* $Author$
* Created by Hannes Fritsche, ESZS, 2025-04-08
*/
#include "uas.h"
namespace ParticipantManagement
{
namespace UasHandling
{
bool Uas::hasChanges(const CreateModifyUasRequest &request)
{
bool hasChanges = request.deviceIdentifier() != m_data.deviceIdentifier.toStdString() ||
request.participantId() != m_data.participantId ||
request.exerciseId() != m_data.exerciseId ||
request.hostname() != m_data.hostname.toStdString() ||
request.hostport() != m_data.hostport ||
request.useTcp() != m_data.useTcp;
if (hasChanges)
{
m_data.deviceIdentifier = QString::fromStdString(request.deviceIdentifier());
m_data.participantId = request.participantId();
m_data.exerciseId = request.exerciseId();
m_data.hostname = QString::fromStdString(request.hostname());
m_data.hostport = request.hostport();
m_data.useTcp = request.useTcp();
}
return hasChanges;
}
bool Uas::compareHostname( const QString &hostname)
{
return (m_data.hostname.compare(hostname, Qt::CaseInsensitive) == 0);
}
bool Uas::compareHostPort(int hostport)
{
return (m_data.hostport == hostport);
}
void Uas::unlinkUas()
{
m_data.participantId = 0;
m_data.exerciseId = 0;
}
void Uas::setState(const ProjectDataManagement::UasState &newState)
{
m_data.uasStateId = newState.underlying();
}
int32_t Uas::id() const
{
return m_data.id;
}
int32_t Uas::participantId() const
{
return m_data.participantId;
}
Database::PpmUas Uas::toDbUas() const
{
return m_data;
}
UAS Uas::toDdsUas() const
{
ParticipantManagement::UAS result;
result.id(m_data.id);
result.deviceIdentifier(m_data.deviceIdentifier.toStdString());
result.uasState(static_cast<ProjectDataManagement::UasState::inner_enum>(m_data.uasStateId));
result.participantId(m_data.participantId);
result.exerciseId(m_data.exerciseId);
result.hostname(m_data.hostname.toStdString());
result.hostport(m_data.hostport);
result.sampleTime(QDateTime::currentDateTimeUtc().toMSecsSinceEpoch());
result.useTcp(m_data.useTcp);
return result;
}
} // namespace ParticipantManagement
} // namespace UasHandling
+43
View File
@@ -0,0 +1,43 @@
/**
* The Uas class represents a Uas. It holds the data and offers some conversion methods.
* $Id$
* $HeadURL$
* $Author$
* Created by Hannes Fritsche, ESZS, 2025-04-08
*/
#pragma once
#include <ParticipantManagement/ppm_db.h>
#include <ParticipantManagement/ppm_dtc.h>
namespace ParticipantManagement
{
namespace UasHandling
{
class Uas
{
public:
explicit Uas(const Database::PpmUas &data)
: m_data(data)
{}
int32_t id() const;
int32_t participantId() const;
Database::PpmUas toDbUas() const;
UAS toDdsUas() const;
bool hasChanges(const CreateModifyUasRequest &request);
void unlinkUas();
void setState(const ProjectDataManagement::UasState &newState);
bool compareHostname( const QString &hostname);
bool compareHostPort(int hostport);
private:
Database::PpmUas m_data;
};
} // namespace UasHandling
} // namespace ParticipantManagement
@@ -0,0 +1,297 @@
/**
* The UasHandler class manages all Uas related function topics and holds classes for
* further Uas data.
* $Id$
* $HeadURL$
* $Author$
* Created by Hannes Fritsche, ESZS, 2025-04-08
*/
#include "uas_handler.h"
#include "uas.h"
#include <ngldb/db_service_handler.h>
#include "main_handler.h"
#include "ParticipantHandling/participant.h"
#include <QJsonDocument>
namespace ParticipantManagement
{
namespace UasHandling
{
//------------------------------------------------------------------------------------------
UasHandler::UasHandler(MainHandler *mainHandler)
: QObject()
, CreateModifyUasRequestHandler(mainHandler->exAnyFts())
, RemoveUasRequestHandler(mainHandler->exAnyFts())
, m_mainHandler(mainHandler)
, m_logger(getLogger("UasHandler"))
{
m_mainHandler->exAnyFts()->enableCreateModifyUas();
m_mainHandler->exAnyFts()->enableRemoveUas();
}
//------------------------------------------------------------------------------------------
UasHandler::~UasHandler()
{
qDeleteAll(m_uass);
}
//------------------------------------------------------------------------------------------
bool UasHandler::init()
{
qDeleteAll(m_uass);
m_uass.clear();
m_mainHandler->exAnyDts()->enableUAS();
QVector<Database::PpmUas> uasVec;
// read parties from db
if (!m_mainHandler->db()->select(uasVec))
{
ERROR_LOG(m_logger) << "Error while reading Uas data from database";
return false;
}
for (const Database::PpmUas &currentUas : qAsConst(uasVec))
{
UasHandling::Uas *newUas = new UasHandling::Uas(currentUas);
m_uass.insert(currentUas.id, newUas);
m_mainHandler->exAnyDts()->publish(newUas->toDdsUas());
}
//now the exercise part
m_exmDtc = ExerciseManagement::Interface::Dtc::create(m_mainHandler->dds());
connect(m_exmDtc.get(), &ExerciseManagement::Interface::Dtc::exerciseChanged,
this, &UasHandler::onExerciseChanged);
if (!m_exmDtc->enableExercise())
{
ERROR_LOG(m_logger) << "Could not enable Topic 'Exercise' of EXM DTC";
return false;
}
//now connect to ppm
connect(m_mainHandler->ddsHandler()->dtc().get(), &Interface::Dtc::uASRadioLinkConnectionStatusChanged, this , &UasHandler::onUASRadioLinkConnectionStatusChanged);
m_mainHandler->ddsHandler()->dtc()->enableUASRadioLinkConnectionStatus();
return true;
}
//------------------------------------------------------------------------------------------
void UasHandler::onCreateModifyUasRequest(const rti::core::SampleIdentity &cookie, const CreateModifyUasRequest &request)
{
Core::FunctionReplyObject reply = request.id() == 0 ? createUas(request) : modifyUas(request);
m_mainHandler->exAnyFts()->createModifyUasReply(cookie, reply);
}
void UasHandler::onRemoveUasRequest(const rti::core::SampleIdentity &cookie, const RemoveUasRequest &request)
{
DEBUG_LOG(m_logger) << "onRemoveUasRequest: " << request;
auto ret = removeUas(request);
if (ret.error())
WARNING_LOG(m_logger) << ret();
m_mainHandler->exAnyFts()->removeUasReply(cookie, ret);
}
Core::FunctionReplyObject UasHandler::removeUas(const RemoveUasRequest &request)
{
DEBUG_LOG(m_logger) << "onRemoveUasRequest " << request;
if (request.id() < 0)
return Core::FunctionReplyObject(tr_lts("dds", "Got request to delete an UAS, but no valid UAS id to delete"));
UasHandling::Uas *uasToDelete = m_uass.value(request.id());
if (!uasToDelete)
return Core::FunctionReplyObject(tr_lts("dds", "Could not delete UAS with id %1, because no UAS with that id exists"))
.arg(request.id());
if (uasToDelete->participantId() > 0)
return Core::FunctionReplyObject(tr_lts("dds", "Not possible to delete a UAS in use"));
DEBUG_LOG(m_logger) << "Removing UAS with ID " << request.id();
return removeUas(uasToDelete);
}
//------------------------------------------------------------------------------------------
Core::FunctionReplyObject UasHandler::removeUas(UasHandling::Uas *uasToDelete)
{
const int uasId = uasToDelete->id();
// delete from db
if (!m_mainHandler->db()->removePpmUas(uasId))
return Core::FunctionReplyObject(tr_lts("dds", "Error removing UAS with id %1 from database")).arg(uasId);
// delete from dds
m_mainHandler->exAnyDts()->removeUASByKey(uasId);
// delete from map
m_uass.remove(uasId);
delete uasToDelete;
return Core::FunctionReplyObject(uasId);
}
//------------------------------------------------------------------------------------------
Core::FunctionReplyObject UasHandler::createUas(const CreateModifyUasRequest &request)
{
DEBUG_LOG(m_logger) << LOGFUNCTION;
// cant check here as we dont have access to all party participants
/*
if (request.participantId() > 0 && !isUasParticipant(request.participantId()))
{
QString error = QStringLiteral("Participant with id %1 is no Uas participant.").arg(request.participantId());
ERROR_LOG(m_logger) << error;
return Core::FunctionReplyObject(error.toStdString().c_str());
}*/
Database::PpmUas dbUas;
dbUas.deviceIdentifier = QString::fromStdString(request.deviceIdentifier());
dbUas.uasStateId = ProjectDataManagement::UasState::Undefined;
dbUas.participantId = request.participantId();
dbUas.exerciseId = request.exerciseId();
dbUas.hostname = QString::fromStdString(request.hostname());
dbUas.hostport = request.hostport();
dbUas.useTcp = request.useTcp();
if (hostNameHostPortExists(dbUas.hostname, dbUas.hostport, -1))
return Core::FunctionReplyObject(tr_lts("dds", "Hostname with Port %1:%2 already exists"))
.arg(dbUas.hostname).arg(dbUas.hostport);
if (!m_mainHandler->db()->insert(dbUas))
{
QString error = QStringLiteral("Could not insert Uas into database");
ERROR_LOG(m_logger) << error;
return Core::FunctionReplyObject(error.toStdString().c_str());
}
UasHandling::Uas *newUas = new UasHandling::Uas(dbUas);
m_uass.insert(newUas->id(), newUas);
m_mainHandler->exAnyDts()->publish(newUas->toDdsUas());
return Core::FunctionReplyObject();
}
//------------------------------------------------------------------------------------------
Core::FunctionReplyObject UasHandler::modifyUas(const CreateModifyUasRequest &request)
{
if (!m_uass.contains(request.id()))
{
QString error = QStringLiteral("Uas topic with id %1 not present. Not possible to modify it.").arg(request.id());
ERROR_LOG(m_logger) << error;
return Core::FunctionReplyObject(error.toStdString().c_str());
}
Uas *uas = m_uass.value(request.id());
// Check if Hostname and Hostport already existing
if (hostNameHostPortExists(QString::fromStdString(request.hostname()), request.hostport(), uas->id()))
return Core::FunctionReplyObject(tr_lts("dds", "Hostname with Port %1:%2 already exists"))
.arg(request.hostname()).arg(request.hostport());
if (!uas->hasChanges(request))
{
QString error = QStringLiteral("There are no changes in modify request.");
ERROR_LOG(m_logger) << error;
return Core::FunctionReplyObject(error.toStdString().c_str());
}
//can't check here))
/*
if (request.participantId() > 0 && !isUasParticipant(request.participantId()))
{
QString error = QStringLiteral("Participant with id %1 is no Uas participant.").arg(request.participantId());
ERROR_LOG(m_logger) << error;
return Core::FunctionReplyObject(error.toStdString().c_str());
}
*/
m_mainHandler->exAnyDts()->publish(uas->toDdsUas());
m_mainHandler->db()->update(uas->toDbUas());
return Core::FunctionReplyObject();
}
//------------------------------------------------------------------------------------------
bool UasHandler::isUasParticipant(int participantId) const
{
const ParticipantManagement::ParticipantHandling::Participant *PARTICIPANT = m_mainHandler->participantHandler()->participantById(participantId);
if (PARTICIPANT == nullptr)
{
WARNING_LOG(m_logger) << "Got invalid participantId " << participantId;
return false;
}
const int TYPE_ID = PARTICIPANT->typeId();
return m_mainHandler->ddsHandler()->dtc()->isTypeUas(TYPE_ID);
}
void UasHandler::onExerciseChanged(const ExerciseManagement::Exercise &data, DataModification mod)
{
Q_UNUSED(mod)
if (data.state() != ExerciseManagement::ExerciseState::Stopped &&
data.state() != ExerciseManagement::ExerciseState::Terminated &&
data.state() != ExerciseManagement::ExerciseState::Unknown )
return;
//Unlink
for (auto uas : m_uass)
{
auto uasData = uas->toDdsUas();
if (uasData.exerciseId() != data.id())
continue;
uas->unlinkUas();
m_mainHandler->exAnyDts()->publish(uas->toDdsUas());
m_mainHandler->db()->update(uas->toDbUas());
}
}
void UasHandler::onUASRadioLinkConnectionStatusChanged(const UASRadioLinkConnectionStatus &data, DataModification mod)
{
if (data.id() <= 0)
return;
if (!m_uass.contains(data.id()))
return;
auto uas = m_uass.value(data.id());
if (mod == DataModification::eRemoved)
uas->setState(ProjectDataManagement::UasState::Undefined);
else
uas->setState(data.uasState());
m_mainHandler->exAnyDts()->publish(uas->toDdsUas());
m_mainHandler->db()->update(uas->toDbUas());
}
bool UasHandler::hostNameHostPortExists(const QString &hostname, int hostport, int uasId)
{
for (Uas *uas : qAsConst(m_uass))
{
if (uas->id() == uasId)
continue;
if (uas->compareHostname(hostname) && uas->compareHostPort(hostport))
return true;
}
return false;
}
} // namespace UasHandling
} // namespace ParticipantManagement
@@ -0,0 +1,61 @@
/**
* The UasHandler class manages all Uas related function topics and holds classes for
* further Uas data.
* $Id$
* $HeadURL$
* $Author$
* Created by Hannes Fritsche, ESZS, 2025-04-08
*/
#pragma once
#include <QtCore/QHash>
#include <QtCore/QObject>
#include <ParticipantManagement/ppm_fts.h>
#include <ExerciseManagement/exm_dtc.h>
#include "logger.h"
namespace ParticipantManagement
{
class MainHandler;
namespace UasHandling
{
class Uas;
class UasHandler final:
public QObject
, protected Interface::Fts::CreateModifyUasRequestHandler
, protected Interface::Fts::RemoveUasRequestHandler
{
Q_OBJECT
public:
explicit UasHandler(MainHandler *mainHandler);
~UasHandler();
bool init();
void onCreateModifyUasRequest(const rti::core::SampleIdentity &cookie, const CreateModifyUasRequest &request) override final;
void onRemoveUasRequest(const rti::core::SampleIdentity &cookie, const RemoveUasRequest &request) override final;
private slots:
void onExerciseChanged(const ExerciseManagement::Exercise &data, DataModification mod);
void onUASRadioLinkConnectionStatusChanged(const UASRadioLinkConnectionStatus &data, DataModification mod);
private:
Core::FunctionReplyObject removeUas(const RemoveUasRequest &request);
Core::FunctionReplyObject removeUas(UasHandling::Uas *uasToDelete);
Core::FunctionReplyObject createUas(const CreateModifyUasRequest &request);
Core::FunctionReplyObject modifyUas(const CreateModifyUasRequest &request);
bool isUasParticipant(int participantId) const;
bool hostNameHostPortExists(const QString &host, int hostport, int uasId);
MainHandler *m_mainHandler;
std::shared_ptr<ExerciseManagement::Interface::Dtc> m_exmDtc;
QHash<int32_t, Uas *> m_uass;
LOGGER_T m_logger;
};
} // namespace UasHandling
} // namespace ParticipantManagement