Initial commit

Lts/Services/ParticipantManagement/UasHandling/object_mission_plan.cpp

@@ -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