Complete Qt6 migration: full clean build green across groups G1-G12 incl. runtime plugin set
new_docker_build.sh gains Group 12 (212 GUI/Data plugins); fixes LtsUtilsGuiDds visibility (LTO-stripped exports), LtsProjectionWorkstation unity name shadow, 6 unity-off dirs (dup file-scope statics, ddsftc INTERFACE sources) and reconfigures BUILD_FILTERMANAGEMENT/BUILD_PLUGINS_SERVICEMONITOR=ON
This commit is contained in:
1 parent
eb1d949edc
commit
815e16368e
1718 files changed
+126739
-18495
No files matched your search
+11
-11
@@ -66,13 +66,13 @@ Core::FunctionReplyObject BiteHandler::callBiteRequest(const rti::core::SampleId
|
||||
const CallBiteRequest &request)
|
||||
{
|
||||
TrainingAreaBase::DemandBiteRequest req;
|
||||
req.equipmentNumbers().reserve(request.participantIds().size());
|
||||
req.withSelfTest(request.withSelfTest());
|
||||
req.equipmentNumbers.reserve(request.participantIds.size());
|
||||
req.withSelfTest = request.withSelfTest;
|
||||
|
||||
bool bOneFound = false;
|
||||
bool bAlreadyDemandedFound = false;
|
||||
QSet<int> currentDemandedParticipants;
|
||||
for (const int participantId : request.participantIds())
|
||||
for (const int participantId : request.participantIds)
|
||||
{
|
||||
if (m_demandedBiteParticipants.contains(participantId))
|
||||
{
|
||||
@@ -98,25 +98,25 @@ Core::FunctionReplyObject BiteHandler::callBiteRequest(const rti::core::SampleId
|
||||
m_demandedBiteParticipants.insert(participant->id());
|
||||
currentDemandedParticipants.insert(participant->id());
|
||||
|
||||
req.equipmentNumbers().push_back(participant->equipmentNumber());
|
||||
req.equipmentNumbers.push_back(participant->equipmentNumber());
|
||||
}
|
||||
|
||||
if (req.equipmentNumbers().size() == 0 && bAlreadyDemandedFound)
|
||||
return Core::FunctionReplyObject(req.requestId());
|
||||
if (req.equipmentNumbers.size() == 0 && bAlreadyDemandedFound)
|
||||
return Core::FunctionReplyObject(req.requestId);
|
||||
|
||||
if (req.equipmentNumbers().size() != 0)
|
||||
if (req.equipmentNumbers.size() != 0)
|
||||
{
|
||||
static int s_requestId = 1;
|
||||
req.requestId(s_requestId++);
|
||||
req.requestId = s_requestId++;
|
||||
|
||||
if (!m_mainHandler->tabFtc()->demandBiteRequest(req, this))
|
||||
return Core::FunctionReplyObject(req.requestId(),
|
||||
return Core::FunctionReplyObject(req.requestId,
|
||||
tr_lts("dds", "Error passing the BITE request to the proxy"));
|
||||
|
||||
QTimer *timeoutTimer = new QTimer(this);
|
||||
timeoutTimer->setSingleShot(true);
|
||||
timeoutTimer->setInterval(5000);
|
||||
const int requestId = req.requestId();
|
||||
const int requestId = req.requestId;
|
||||
m_demandedBiteParticipantRequests.insert(requestId, {currentDemandedParticipants, cookie, timeoutTimer});
|
||||
|
||||
auto cb = [this, requestId]()
|
||||
@@ -129,7 +129,7 @@ Core::FunctionReplyObject BiteHandler::callBiteRequest(const rti::core::SampleId
|
||||
// at least one found but this was already requested and we're waiting for answer -> don't answer with error
|
||||
if (bOneFound)
|
||||
return Core::FunctionReplyObject();
|
||||
return Core::FunctionReplyObject(req.requestId(),
|
||||
return Core::FunctionReplyObject(req.requestId,
|
||||
tr_lts("dds", "Got no valid participants for BITE request"));
|
||||
}
|
||||
|
||||
|
||||
+30
-30
@@ -50,14 +50,14 @@ void ParticipantManagement::EquipmentEventHandling::EquipmentEventHandler::onEqu
|
||||
|
||||
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());
|
||||
" 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;
|
||||
|
||||
@@ -87,22 +87,22 @@ void ParticipantManagement::EquipmentEventHandling::EquipmentEventHandler::onEqu
|
||||
id |= q.value(i++).toInt();
|
||||
keys += id;
|
||||
|
||||
data.id(id);
|
||||
data.id = id;
|
||||
|
||||
data.equipmentNumber(q.value(i++).toInt());
|
||||
data.timeStamp(q.value(i++).toLongLong());
|
||||
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());
|
||||
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);
|
||||
data.eventData = LtsUtils::convert<std::vector<uint8_t>>(evtData);
|
||||
data.filterId = m_filterId;
|
||||
|
||||
m_mainHandler->dts()->publish(data);
|
||||
}
|
||||
@@ -118,22 +118,22 @@ void ParticipantManagement::EquipmentEventHandling::EquipmentEventHandler::onEqu
|
||||
|
||||
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));
|
||||
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());
|
||||
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() ;
|
||||
ERROR_LOG(m_logger) << "Error publishing equipment event to dds from eqnr: " << event.equipmentNumber ;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+6
-6
@@ -36,10 +36,10 @@ Core::FunctionReplyObject FiringUnitValidator::firingUnitError(const QHash<int,
|
||||
|
||||
for (const ParticipantData ¤tData : participantData)
|
||||
{
|
||||
if (!m_typeHandler->isFiringUnitType(currentData.typeId()))
|
||||
if (!m_typeHandler->isFiringUnitType(currentData.typeId))
|
||||
continue;
|
||||
|
||||
int unitModId = currentData.modId();
|
||||
int unitModId = currentData.modId;
|
||||
|
||||
error = getError(modIdToParticipantId, participantData, unitModId);
|
||||
|
||||
@@ -61,7 +61,7 @@ QString FiringUnitValidator::getError(const QHash<int, int> &modIdToParticipantI
|
||||
|
||||
for (const ParticipantData ¤tData : participantData)
|
||||
{
|
||||
if (currentData.superiorModId() != unitModId)
|
||||
if (currentData.superiorModId != unitModId)
|
||||
continue;
|
||||
|
||||
// capacity error
|
||||
@@ -71,16 +71,16 @@ QString FiringUnitValidator::getError(const QHash<int, int> &modIdToParticipantI
|
||||
return tr("There are only %1 participants allowed per firing unit.").arg(maxParticipantsPerFiringUnit);
|
||||
|
||||
// false type error
|
||||
hasFalseTypeError = !m_typeHandler->isArtilleryParticipantType(currentData.typeId());
|
||||
hasFalseTypeError = !m_typeHandler->isArtilleryParticipantType(currentData.typeId);
|
||||
|
||||
if (hasFalseTypeError)
|
||||
return tr("There are only artillery participants allowed in firing units.");
|
||||
|
||||
// mixed type error
|
||||
if (typeId == -1)
|
||||
typeId = currentData.typeId();
|
||||
typeId = currentData.typeId;
|
||||
|
||||
hasMixedTypeError = currentData.typeId() != typeId;
|
||||
hasMixedTypeError = currentData.typeId != typeId;
|
||||
|
||||
if (hasMixedTypeError)
|
||||
return tr("There are no mixed types allowed in firing units.");
|
||||
|
||||
+7
-7
@@ -39,7 +39,7 @@ void GetParticipants::onGetParticipantsRequest(const rti::core::SampleIdentity &
|
||||
recordReplay.initDtc(nullptr, m_mainHandler->exerciseId());
|
||||
|
||||
NSqlQuery q(m_mainHandler->db()->database());
|
||||
recordReplay.readParticipantAt(q, request.timeStamp());
|
||||
recordReplay.readParticipantAt(q, request.timeStamp);
|
||||
|
||||
// key is sampleTime -> multiMap
|
||||
auto participantsMmap = recordReplay.getParticipantMap();
|
||||
@@ -49,23 +49,23 @@ void GetParticipants::onGetParticipantsRequest(const rti::core::SampleIdentity &
|
||||
for (auto it = participantsMmap.begin(); it != participantsMmap.end(); ++it)
|
||||
{
|
||||
Participant &p = it.value();
|
||||
if (p.isDeleted())
|
||||
participants.remove(p.id());
|
||||
if (p.isDeleted)
|
||||
participants.remove(p.id);
|
||||
else
|
||||
participants[p.id()] = std::move(p);
|
||||
participants[p.id] = std::move(p);
|
||||
}
|
||||
|
||||
DEBUG_LOG(m_logger) << "Starting to read participant from record replay. Size: "
|
||||
<< participants.size();
|
||||
|
||||
GetParticipantsReply reply;
|
||||
reply.requestId(request.requestId());
|
||||
reply.requestId = request.requestId;
|
||||
|
||||
auto &vecPart = reply.participants();
|
||||
auto &vecPart = reply.participants;
|
||||
vecPart.reserve(participants.size());
|
||||
for (auto it = participants.begin(); it != participants.end(); ++it)
|
||||
{
|
||||
if (request.partyId() >= 0 && it.value().partyId() != request.partyId())
|
||||
if (request.partyId >= 0 && it.value().partyId != request.partyId)
|
||||
continue;
|
||||
vecPart.push_back(it.value());
|
||||
}
|
||||
|
||||
+264
-264
File diff suppressed because it is too large.
Load diff
+8
-8
@@ -35,15 +35,15 @@ public:
|
||||
|
||||
virtual ~Participant();
|
||||
|
||||
int32_t id() const { return m_participantData.id(); }
|
||||
int32_t typeId() const { return m_participantData.typeId(); }
|
||||
int32_t superiorId() const { return m_participantData.superiorId(); }
|
||||
int32_t id() const { return m_participantData.id; }
|
||||
int32_t typeId() const { return m_participantData.typeId; }
|
||||
int32_t superiorId() const { return m_participantData.superiorId; }
|
||||
// return optional?
|
||||
int32_t equipmentNumber() const { return m_participantData.equipmentNumber.is_set() ? m_participantData.equipmentNumber.get() : 0; }
|
||||
int32_t partyId() const { return m_participantData.partyId(); }
|
||||
bool isDeleted() const { return m_participantData.isDeleted(); }
|
||||
ParticipantAssignState assignState() const { return m_participantData.assignState(); }
|
||||
const std::vector<int32_t> &inferiors() const { return m_participantData.inferiorIds(); }
|
||||
int32_t equipmentNumber() const { return m_participantData.equipmentNumber.has_value() ? m_participantData.equipmentNumber.get() : 0; }
|
||||
int32_t partyId() const { return m_participantData.partyId; }
|
||||
bool isDeleted() const { return m_participantData.isDeleted; }
|
||||
ParticipantAssignState assignState() const { return m_participantData.assignState; }
|
||||
const std::vector<int32_t> &inferiors() const { return m_participantData.inferiorIds; }
|
||||
ParticipantPosition position() const { return m_positionPublished; }
|
||||
const DynamicParticipantData &dynamicParticipantData() const { return m_dynamicData; }
|
||||
const ParticipantManagement::Participant &participantData() const { return m_participantData; }
|
||||
|
||||
+12
-12
@@ -52,8 +52,8 @@ bool ParticipantForExercise::applyEquipmentExerciseMapping(int newEqId)
|
||||
<< ", " << dbEem.exerciseId;
|
||||
if (!m_mainHandler->dbEx0()->insert(dbEem))
|
||||
{
|
||||
m_participantData.equipmentNumber().reset();
|
||||
m_participantData.assignState(ParticipantAssignState::NotAssigned);
|
||||
m_participantData.equipmentNumber.reset();
|
||||
m_participantData.assignState = ParticipantAssignState::NotAssigned;
|
||||
publishParticipant();
|
||||
return false;
|
||||
}
|
||||
@@ -104,15 +104,15 @@ void ParticipantForExercise::removeFromDds() // only called on shutdown
|
||||
|
||||
void ParticipantForExercise::registerInfoFromFt(const RegisterParticipantRequest &request)
|
||||
{
|
||||
m_participantData.info(request.info());
|
||||
m_participantData.identification(request.identification());
|
||||
m_participantData.info = request.info;
|
||||
m_participantData.identification = request.identification;
|
||||
}
|
||||
|
||||
bool ParticipantForExercise::registerFromFt(const RegisterParticipantRequest &request)
|
||||
{
|
||||
int newEquipmentNumber = request.equipmentNumber();
|
||||
int newEquipmentNumber = request.equipmentNumber;
|
||||
// just to be sure ...
|
||||
if (request.assignState() == ParticipantAssignState::NotAssigned)
|
||||
if (request.assignState == ParticipantAssignState::NotAssigned)
|
||||
newEquipmentNumber = 0;
|
||||
|
||||
if (!updateEquipmentExerciseMapping(equipmentNumber(), newEquipmentNumber))
|
||||
@@ -122,17 +122,17 @@ bool ParticipantForExercise::registerFromFt(const RegisterParticipantRequest &re
|
||||
id());
|
||||
|
||||
INFO_LOG(m_logger) << "Set assign state for participant " << id() << " from "
|
||||
<< assignState() << " to " << request.assignState()
|
||||
<< assignState() << " to " << request.assignState
|
||||
<< ", old eqid: " << equipmentNumber() << ", new eqid: "
|
||||
<< newEquipmentNumber;
|
||||
|
||||
if (newEquipmentNumber)
|
||||
m_participantData.equipmentNumber(newEquipmentNumber);
|
||||
m_participantData.equipmentNumber = newEquipmentNumber;
|
||||
else
|
||||
m_participantData.equipmentNumber().reset();
|
||||
m_participantData.assignState(request.assignState());
|
||||
m_participantData.info(request.info());
|
||||
m_participantData.identification(request.identification());
|
||||
m_participantData.equipmentNumber.reset();
|
||||
m_participantData.assignState = request.assignState;
|
||||
m_participantData.info = request.info;
|
||||
m_participantData.identification = request.identification;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
+186
-186
@@ -41,7 +41,7 @@ void ParticipantHandler::clearParticipants()
|
||||
{
|
||||
// clear maps
|
||||
for (auto it = m_hitLineInfoMap.cbegin(); it != m_hitLineInfoMap.cend(); ++it)
|
||||
dts()->removeHitLineInfoByKey(it.value().id());
|
||||
dts()->removeHitLineInfoByKey(it.value().id);
|
||||
m_hitLineInfoMap.clear();
|
||||
|
||||
for (auto p : std::as_const(m_participants))
|
||||
@@ -97,49 +97,49 @@ void ParticipantHandler::onNewGearEvent(const TrainingAreaBase::EquipmentGearEve
|
||||
{
|
||||
if (isTelegramInFuture(gearEvent))
|
||||
{
|
||||
WARNING_LOG(m_logger) << "Got an EquipmentGearEvent which has a timestamp in the future: " << gearEvent.sampleTime();
|
||||
WARNING_LOG(m_logger) << "Got an EquipmentGearEvent which has a timestamp in the future: " << gearEvent.sampleTime;
|
||||
return;
|
||||
}
|
||||
|
||||
// NOTE: gearEvent.chargeAmount() is not used because there is no usecase for this value ... atm
|
||||
|
||||
Participant *participantToBeChanged = participantByEquipmentNumber(gearEvent.equipmentNumber());
|
||||
Participant *participantToBeChanged = participantByEquipmentNumber(gearEvent.equipmentNumber);
|
||||
if (!participantToBeChanged)
|
||||
{
|
||||
WARNING_LOG(m_logger) << "Got gear charge state for unknown equipment number " << gearEvent.equipmentNumber();
|
||||
WARNING_LOG(m_logger) << "Got gear charge state for unknown equipment number " << gearEvent.equipmentNumber;
|
||||
return;
|
||||
}
|
||||
|
||||
participantToBeChanged->setGearCharge(gearEvent.charge(), gearEvent.sampleTime());
|
||||
participantToBeChanged->setGearCharge(gearEvent.charge, gearEvent.sampleTime);
|
||||
participantToBeChanged->publishDynamicData();
|
||||
|
||||
// publish gear event
|
||||
dts()->publish(
|
||||
ParticipantGearEvent(participantToBeChanged->id(),
|
||||
gearEvent.sampleTime(),
|
||||
gearEvent.chargeAmount(),
|
||||
GearCharge(gearEvent.charge().gearId(), gearEvent.charge().gearTypeId(), gearEvent.charge().chargeTypeId(), gearEvent.charge().remain())));
|
||||
gearEvent.sampleTime,
|
||||
gearEvent.chargeAmount,
|
||||
GearCharge(gearEvent.charge.gearId, gearEvent.charge.gearTypeId, gearEvent.charge.chargeTypeId, gearEvent.charge.remain)));
|
||||
}
|
||||
|
||||
void ParticipantHandler::onNewGearChargeStateFromProxy(const TrainingAreaBase::EquipmentGearChargeState &chargeState)
|
||||
{
|
||||
if (isTelegramInFuture(chargeState))
|
||||
{
|
||||
WARNING_LOG(m_logger) << "Got an EquipmentGearChargeState which has a timestamp in the future: " << chargeState.sampleTime();
|
||||
WARNING_LOG(m_logger) << "Got an EquipmentGearChargeState which has a timestamp in the future: " << chargeState.sampleTime;
|
||||
return;
|
||||
}
|
||||
|
||||
const int equipNo = chargeState.equipmentNumber();
|
||||
const int equipNo = chargeState.equipmentNumber;
|
||||
Participant *participantToBeChanged = equipNo < 0 ? participantById(-equipNo) : participantByEquipmentNumber(equipNo);
|
||||
|
||||
if (!participantToBeChanged)
|
||||
{
|
||||
WARNING_LOG(m_logger) << "Got gear charge state for unknown equipment number " << chargeState.equipmentNumber();
|
||||
WARNING_LOG(m_logger) << "Got gear charge state for unknown equipment number " << chargeState.equipmentNumber;
|
||||
return;
|
||||
}
|
||||
|
||||
for (const TrainingAreaBase::GearCharge &charge : chargeState.charge())
|
||||
participantToBeChanged->setGearCharge(charge, chargeState.sampleTime());
|
||||
for (const TrainingAreaBase::GearCharge &charge : chargeState.charge)
|
||||
participantToBeChanged->setGearCharge(charge, chargeState.sampleTime);
|
||||
participantToBeChanged->publishDynamicData();
|
||||
|
||||
emit gearChargeChanged(participantToBeChanged->id(), participantToBeChanged->partyId());
|
||||
@@ -149,13 +149,13 @@ void ParticipantHandler::onNewGearAssignmentFromProxy(const TrainingAreaBase::Eq
|
||||
{
|
||||
if (isTelegramInFuture(gearAssignment))
|
||||
{
|
||||
WARNING_LOG(m_logger) << "Got an EquipmentGearAssignment which has a timestamp in the future: " << gearAssignment.sampleTime();
|
||||
WARNING_LOG(m_logger) << "Got an EquipmentGearAssignment which has a timestamp in the future: " << gearAssignment.sampleTime;
|
||||
return;
|
||||
}
|
||||
Participant *participantToBeChanged = participantByEquipmentNumber(gearAssignment.equipmentNumber());
|
||||
Participant *participantToBeChanged = participantByEquipmentNumber(gearAssignment.equipmentNumber);
|
||||
if (!participantToBeChanged)
|
||||
{
|
||||
WARNING_LOG(m_logger) << "Got gear assignment for unknown equipment number " << gearAssignment.equipmentNumber();
|
||||
WARNING_LOG(m_logger) << "Got gear assignment for unknown equipment number " << gearAssignment.equipmentNumber;
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -167,34 +167,34 @@ void ParticipantHandler::onNewStateFromProxy(const TrainingAreaBase::EquipmentSt
|
||||
{
|
||||
if (isTelegramInFuture(data))
|
||||
{
|
||||
WARNING_LOG(m_logger) << "Got an EquipmentState which has a timestamp in the future: " << data.sampleTime();
|
||||
WARNING_LOG(m_logger) << "Got an EquipmentState which has a timestamp in the future: " << data.sampleTime;
|
||||
return;
|
||||
}
|
||||
|
||||
// 1. handle included EquipmentPosition:
|
||||
TrainingAreaBase::EquipmentPosition pos;
|
||||
pos.equipmentNumber(data.equipmentNumber());
|
||||
pos.sampleTime(data.sampleTime());
|
||||
if (data.position.is_set())
|
||||
pos.equipmentNumber = data.equipmentNumber;
|
||||
pos.sampleTime = data.sampleTime;
|
||||
if (data.position.has_value())
|
||||
{
|
||||
pos.position(data.position.get());
|
||||
pos.position = data.position.get();
|
||||
onNewPositionFromProxy(pos);
|
||||
}
|
||||
|
||||
// 2. handle EquipmentState
|
||||
Participant *participantToBeChanged = participantByEquipmentNumber(data.equipmentNumber());
|
||||
Participant *participantToBeChanged = participantByEquipmentNumber(data.equipmentNumber);
|
||||
if (!participantToBeChanged)
|
||||
{
|
||||
WARNING_LOG(m_logger) << "Got equipment state for unknown equipment number " << data.equipmentNumber();
|
||||
WARNING_LOG(m_logger) << "Got equipment state for unknown equipment number " << data.equipmentNumber;
|
||||
return;
|
||||
}
|
||||
|
||||
// convert eqNo to participantId if originator was a participant and data.originatorId() is an equipment number
|
||||
int originatorId = data.originatorId();
|
||||
int originatorId = data.originatorId;
|
||||
Participant *originParticipant = nullptr;
|
||||
if (data.originatorType() == ProjectDataManagement::StateChangeOriginator::Participant)
|
||||
if (data.originatorType == ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_Participant)
|
||||
{
|
||||
originParticipant = participantByEquipmentNumber(data.originatorId());
|
||||
originParticipant = participantByEquipmentNumber(data.originatorId);
|
||||
if (originParticipant)
|
||||
originatorId = originParticipant->id();
|
||||
else
|
||||
@@ -203,20 +203,20 @@ void ParticipantHandler::onNewStateFromProxy(const TrainingAreaBase::EquipmentSt
|
||||
|
||||
// Make Laser Designations to Laser Designations
|
||||
auto dtcPdm = m_bdp->pdmDtc();
|
||||
if (dtcPdm && dtcPdm->getChargeTypeSpecialProperty(data.originatorChargeTypeId(), 0, 0) == ProjectDataManagement::ChargeTypeProperty::LTD && originParticipant)
|
||||
if (dtcPdm && dtcPdm->getChargeTypeSpecialProperty(data.originatorChargeTypeId, 0, 0) == ProjectDataManagement::ChargeTypeProperty::LTD && originParticipant)
|
||||
{
|
||||
QSet<int> ldGearTypes{1043}; // Need Property for LTD...
|
||||
DynamicParticipantData dpd = originParticipant->dynamicParticipantData();
|
||||
auto it = std::find_if(dpd.gear().cbegin(), dpd.gear().cend(), [ldGearTypes](const GearInformation &gi) { return ldGearTypes.contains(gi.gearTypeId()); });
|
||||
if (it != dpd.gear().cend())
|
||||
auto it = std::find_if(dpd.gear.cbegin(), dpd.gear.cend(), [ldGearTypes](const GearInformation &gi) { return ldGearTypes.contains(gi.gearTypeId); });
|
||||
if (it != dpd.gear.cend())
|
||||
{
|
||||
for (auto &ld : dpd.designations())
|
||||
for (auto &ld : dpd.designations)
|
||||
{
|
||||
if (ld.gearId() != it->gearId())
|
||||
if (ld.gearId != it->gearId)
|
||||
continue;
|
||||
|
||||
ld.spotLocation() = pos.position().position();
|
||||
ld.outputPower() = 1.0;
|
||||
ld.spotLocation = pos.position.position;
|
||||
ld.outputPower = 1.0;
|
||||
originParticipant->setDynamicData(dpd);
|
||||
originParticipant->publishDynamicData();
|
||||
break;
|
||||
@@ -229,7 +229,7 @@ void ParticipantHandler::onNewStateFromProxy(const TrainingAreaBase::EquipmentSt
|
||||
|
||||
participantToBeChanged->publishDynamicData();
|
||||
|
||||
createHitlineInfo(originatorId, originParticipant, participantToBeChanged, pos, data.originatorChargeTypeId(), data.sampleTime());
|
||||
createHitlineInfo(originatorId, originParticipant, participantToBeChanged, pos, data.originatorChargeTypeId, data.sampleTime);
|
||||
}
|
||||
|
||||
void ParticipantHandler::createHitlineInfo(int, Participant *, Participant *, const TrainingAreaBase::EquipmentPosition &, int, qint64)
|
||||
@@ -242,17 +242,17 @@ void ParticipantHandler::onNewPositionFromProxy(const TrainingAreaBase::Equipmen
|
||||
{
|
||||
if (isTelegramInFuture(position))
|
||||
{
|
||||
WARNING_LOG(m_logger) << "Got an EquipmentPosition which has a timestamp in the future: " << position.sampleTime();
|
||||
WARNING_LOG(m_logger) << "Got an EquipmentPosition which has a timestamp in the future: " << position.sampleTime;
|
||||
return;
|
||||
}
|
||||
if (isTelegramOutdated(position) && position.position().reportingSource() != Core::PositionReportingSource::SetByOperator)
|
||||
if (isTelegramOutdated(position) && position.position.reportingSource != Core::PositionReportingSource::SetByOperator)
|
||||
{
|
||||
INFO_LOG(m_logger) << "position is outdated: " << position;
|
||||
return;
|
||||
}
|
||||
DEBUG_LOG(m_logger) << "Got new position from proxy: " << position;
|
||||
|
||||
const int equipNo = position.equipmentNumber();
|
||||
const int equipNo = position.equipmentNumber;
|
||||
// negative - treat as participantId
|
||||
Participant *participantWithNewPosition = equipNo < 0 ? participantById(-equipNo) : participantByEquipmentNumber(equipNo);
|
||||
|
||||
@@ -270,11 +270,11 @@ void ParticipantHandler::onNewEquipmentOperationalStateFromProxy(const TrainingA
|
||||
{
|
||||
if (isTelegramInFuture(operationalState))
|
||||
{
|
||||
WARNING_LOG(m_logger) << "Got an EquipmentOperationalState which has a timestamp in the future: " << operationalState.sampleTime();
|
||||
WARNING_LOG(m_logger) << "Got an EquipmentOperationalState which has a timestamp in the future: " << operationalState.sampleTime;
|
||||
return;
|
||||
}
|
||||
|
||||
Participant *participantToUpdate = participantByEquipmentNumber(operationalState.equipmentNumber());
|
||||
Participant *participantToUpdate = participantByEquipmentNumber(operationalState.equipmentNumber);
|
||||
if (!participantToUpdate)
|
||||
{
|
||||
WARNING_LOG(m_logger) << "Got EquipmentOperationalState for unknown equipment number: " << operationalState;
|
||||
@@ -289,30 +289,30 @@ void ParticipantHandler::onNewBiteFromProxy(const TrainingAreaBase::EquipmentBit
|
||||
{
|
||||
if (isTelegramInFuture(bite))
|
||||
{
|
||||
WARNING_LOG(m_logger) << "Got an EquipmentBite which has a timestamp in the future: " << bite.sampleTime();
|
||||
WARNING_LOG(m_logger) << "Got an EquipmentBite which has a timestamp in the future: " << bite.sampleTime;
|
||||
return;
|
||||
}
|
||||
if (isTelegramOutdated(bite))
|
||||
{
|
||||
WARNING_LOG(m_logger) << "Got an EquipmentBite which has a timestamp in the past: " << bite.sampleTime();
|
||||
WARNING_LOG(m_logger) << "Got an EquipmentBite which has a timestamp in the past: " << bite.sampleTime;
|
||||
return;
|
||||
}
|
||||
|
||||
Bite biteData;
|
||||
|
||||
Participant *p = participantByEquipmentNumber(bite.equipmentNumber());
|
||||
biteData.participantId(p ? p->id() : -1);
|
||||
biteData.equipmentNumber(bite.equipmentNumber());
|
||||
biteData.sampleTime(bite.sampleTime());
|
||||
biteData.registerType(bite.registerType());
|
||||
biteData.biteState(bite.biteState());
|
||||
biteData.configState(bite.configState());
|
||||
biteData.batteryState(bite.batteryState());
|
||||
biteData.configError(bite.configError());
|
||||
Participant *p = participantByEquipmentNumber(bite.equipmentNumber);
|
||||
biteData.participantId = p ? p->id() : -1;
|
||||
biteData.equipmentNumber = bite.equipmentNumber;
|
||||
biteData.sampleTime = bite.sampleTime;
|
||||
biteData.registerType = bite.registerType;
|
||||
biteData.biteState = bite.biteState;
|
||||
biteData.configState = bite.configState;
|
||||
biteData.batteryState = bite.batteryState;
|
||||
biteData.configError = bite.configError;
|
||||
|
||||
biteData.biteErrors().reserve(bite.biteErrors().size());
|
||||
for (const TrainingAreaBase::EquipmentBiteError &error : bite.biteErrors())
|
||||
biteData.biteErrors().emplace_back(error.errorNumber(), error.canDeviceNumber(), error.subdeviceNumber(), error.uniqueId());
|
||||
biteData.biteErrors.reserve(bite.biteErrors.size());
|
||||
for (const TrainingAreaBase::EquipmentBiteError &error : bite.biteErrors)
|
||||
biteData.biteErrors.emplace_back(error.errorNumber, error.canDeviceNumber, error.subdeviceNumber, error.uniqueId);
|
||||
|
||||
dts()->publish(biteData);
|
||||
}
|
||||
@@ -321,11 +321,11 @@ void ParticipantHandler::onNewCtaDataErrorFromProxy(const TrainingAreaBase::CtaD
|
||||
{
|
||||
CtaError ctasErrorData;
|
||||
|
||||
ctasErrorData.equipmentNumber(error.equipmentNumber());
|
||||
ctasErrorData.timeReceipt(currentTimeMSec());
|
||||
ctasErrorData.timePlayerUnit(error.sampleTime());
|
||||
ctasErrorData.errorReason(error.reason());
|
||||
ctasErrorData.telegramId(error.originTelegramId());
|
||||
ctasErrorData.equipmentNumber = error.equipmentNumber;
|
||||
ctasErrorData.timeReceipt = currentTimeMSec();
|
||||
ctasErrorData.timePlayerUnit = error.sampleTime;
|
||||
ctasErrorData.errorReason = error.reason;
|
||||
ctasErrorData.telegramId = error.originTelegramId;
|
||||
|
||||
dts()->publish(ctasErrorData);
|
||||
}
|
||||
@@ -334,39 +334,39 @@ void ParticipantHandler::onNewParticipantModeReport(const TrainingAreaBase::Part
|
||||
{
|
||||
if (isTelegramInFuture(report))
|
||||
{
|
||||
WARNING_LOG(m_logger) << "Got a ParticipantModeReport which has a timestamp in the future: " << report.sampleTime();
|
||||
WARNING_LOG(m_logger) << "Got a ParticipantModeReport which has a timestamp in the future: " << report.sampleTime;
|
||||
return;
|
||||
}
|
||||
if (isTelegramOutdated(report))
|
||||
{
|
||||
WARNING_LOG(m_logger) << "Got a ParticipantModeReport which has a timestamp in the past: " << report.sampleTime();
|
||||
WARNING_LOG(m_logger) << "Got a ParticipantModeReport which has a timestamp in the past: " << report.sampleTime;
|
||||
return;
|
||||
}
|
||||
|
||||
Participant *participant = participantByEquipmentNumber(report.equipmentNumber());
|
||||
Participant *participant = participantByEquipmentNumber(report.equipmentNumber);
|
||||
if (!participant)
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << report.equipmentNumber();
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << report.equipmentNumber;
|
||||
return;
|
||||
}
|
||||
|
||||
ParticipantMode ddsData;
|
||||
|
||||
ddsData.participantId(participant->id());
|
||||
ddsData.language(report.language());
|
||||
ddsData.opMode(report.operationMode());
|
||||
ddsData.reactivationDecontamination(report.reactivationDetoxication());
|
||||
ddsData.reactivationMaintenance(report.reactivationMaintenance());
|
||||
ddsData.reactivationMedic(report.reactivationMedic());
|
||||
ddsData.modeVest(report.protectionModeVest());
|
||||
ddsData.modeHelmet(report.protectionModeHelmet());
|
||||
ddsData.modePersonalProtection(report.personellProtectionMode());
|
||||
ddsData.protectionLevel(report.protectionLevel());
|
||||
ddsData.handgrenadeSearchMode(report.handgrenadeSearchMode());
|
||||
ddsData.internationalMode(report.internationalMode());
|
||||
ddsData.abcProtectionMode(report.abcProtectionMode());
|
||||
ddsData.participantId = participant->id();
|
||||
ddsData.language = report.language;
|
||||
ddsData.opMode = report.operationMode;
|
||||
ddsData.reactivationDecontamination = report.reactivationDetoxication;
|
||||
ddsData.reactivationMaintenance = report.reactivationMaintenance;
|
||||
ddsData.reactivationMedic = report.reactivationMedic;
|
||||
ddsData.modeVest = report.protectionModeVest;
|
||||
ddsData.modeHelmet = report.protectionModeHelmet;
|
||||
ddsData.modePersonalProtection = report.personellProtectionMode;
|
||||
ddsData.protectionLevel = report.protectionLevel;
|
||||
ddsData.handgrenadeSearchMode = report.handgrenadeSearchMode;
|
||||
ddsData.internationalMode = report.internationalMode;
|
||||
ddsData.abcProtectionMode = report.abcProtectionMode;
|
||||
|
||||
ddsData.sampleTime(report.sampleTime());
|
||||
ddsData.sampleTime = report.sampleTime;
|
||||
participant->setMode(ddsData);
|
||||
participant->publishMode();
|
||||
}
|
||||
@@ -375,30 +375,30 @@ void ParticipantHandler::onNewSpecialSensorData(const TrainingAreaBase::SpecialS
|
||||
{
|
||||
if (isTelegramInFuture(data))
|
||||
{
|
||||
WARNING_LOG(m_logger) << "Got a SpecialSensorData which has a timestamp in the future: " << data.sampleTime();
|
||||
WARNING_LOG(m_logger) << "Got a SpecialSensorData which has a timestamp in the future: " << data.sampleTime;
|
||||
return;
|
||||
}
|
||||
if (isTelegramOutdated(data))
|
||||
{
|
||||
WARNING_LOG(m_logger) << "Got a SpecialSensorData which has a timestamp in the past: " << data.sampleTime();
|
||||
WARNING_LOG(m_logger) << "Got a SpecialSensorData which has a timestamp in the past: " << data.sampleTime;
|
||||
return;
|
||||
}
|
||||
|
||||
Participant *participant = data.equipmentNumber() < 0 ? participantById(-data.equipmentNumber()) : participantByEquipmentNumber(data.equipmentNumber());
|
||||
Participant *participant = data.equipmentNumber < 0 ? participantById(-data.equipmentNumber) : participantByEquipmentNumber(data.equipmentNumber);
|
||||
|
||||
if (!participant)
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber();
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber;
|
||||
return;
|
||||
}
|
||||
|
||||
TrainingAreaBase::EquipmentPosition pos;
|
||||
pos.equipmentNumber(data.equipmentNumber());
|
||||
pos.sampleTime(data.sampleTime());
|
||||
if (data.position.is_set())
|
||||
pos.equipmentNumber = data.equipmentNumber;
|
||||
pos.sampleTime = data.sampleTime;
|
||||
if (data.position.has_value())
|
||||
{
|
||||
Core::GeoPosition geoPos(data.position.get().lon(), data.position.get().lat(), 0);
|
||||
pos.position().position(geoPos);
|
||||
Core::GeoPosition geoPos(data.position.get().lon, data.position.get().lat, 0);
|
||||
pos.position.position = geoPos;
|
||||
if (participant->setPosition(pos))
|
||||
participant->publishPosition();
|
||||
}
|
||||
@@ -410,13 +410,13 @@ void ParticipantHandler::onNewSpecialSensorData(const TrainingAreaBase::SpecialS
|
||||
void ParticipantHandler::onNewLaserDesignation(const TrainingAreaBase::LaserDesignation &data)
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "New Laser Designation: "
|
||||
<< "Code: " << data.code() << ", GearID: " << data.gearId() << ", EqNo: " << data.equipmentNumber() << ", Lon: " << data.spotLocation().lon()
|
||||
<< ", Lat: " << data.spotLocation().lat() << ", Power: " << data.outputPower();
|
||||
Participant *participant = participantByEquipmentNumber(data.equipmentNumber());
|
||||
<< "Code: " << data.code << ", GearID: " << data.gearId << ", EqNo: " << data.equipmentNumber << ", Lon: " << data.spotLocation.lon
|
||||
<< ", Lat: " << data.spotLocation.lat << ", Power: " << data.outputPower;
|
||||
Participant *participant = participantByEquipmentNumber(data.equipmentNumber);
|
||||
|
||||
if (!participant)
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber();
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber;
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -457,17 +457,17 @@ void ParticipantHandler::onLaserDesignationRemoved(int equipmentNumber, int gear
|
||||
void ParticipantHandler::onBuildingHitLineInfo(const Buildings::BuildingHitLineInfo &data)
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "onBuildingHitLineInfo "
|
||||
<< "BuildingId=" << data.buildingId() << " originatorParticipantId=" << data.originatorParticipantId();
|
||||
<< "BuildingId=" << data.buildingId << " originatorParticipantId=" << data.originatorParticipantId;
|
||||
auto dtcPdm = m_bdp->pdmDtc();
|
||||
// NOTE: igniterTypeId/IgniterFunction = 0 as long as BuildingHitLineInfo does not contain values
|
||||
if (dtcPdm->getChargeTypeSpecialProperty(data.chargeTypeId(), 0, 0) != ProjectDataManagement::ChargeTypeProperty::LTD)
|
||||
if (dtcPdm->getChargeTypeSpecialProperty(data.chargeTypeId, 0, 0) != ProjectDataManagement::ChargeTypeProperty::LTD)
|
||||
return;
|
||||
|
||||
Participant *participant = participantById(data.originatorParticipantId());
|
||||
Participant *participant = participantById(data.originatorParticipantId);
|
||||
|
||||
if (!participant)
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with participantId: " << data.originatorParticipantId();
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with participantId: " << data.originatorParticipantId;
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -480,68 +480,68 @@ void ParticipantHandler::onBuildingHitLineInfo(const Buildings::BuildingHitLineI
|
||||
DEBUG_LOG(m_logger) << "setDynamicData";
|
||||
participant->setDynamicData(dpd);
|
||||
DEBUG_LOG(m_logger) << "publishDynamicData"
|
||||
<< " dpd.designations().size()=" << dpd.designations().size();
|
||||
<< " dpd.designations().size()=" << dpd.designations.size();
|
||||
participant->publishDynamicData();
|
||||
}
|
||||
|
||||
void ParticipantHandler::onSanitaryMaterialStockReport(const TrainingAreaBase::ParticipantSanitaryMaterialStockReport &data)
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "onSanitaryMaterialStockReport";
|
||||
Participant *participant = participantByEquipmentNumber(data.equipmentNumber());
|
||||
Participant *participant = participantByEquipmentNumber(data.equipmentNumber);
|
||||
if (!participant)
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber();
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber;
|
||||
return;
|
||||
}
|
||||
if (data.qualification() == TrainingAreaBase::Qualification::NotDefined)
|
||||
if (data.qualification == TrainingAreaBase::Qualification::NotDefined)
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "!!! Clear Materials : equipment number " << data.equipmentNumber();
|
||||
DEBUG_LOG(m_logger) << "!!! Clear Materials : sample time " << data.sampleTime();
|
||||
DEBUG_LOG(m_logger) << "!!! Clear Materials : equipment number " << data.equipmentNumber;
|
||||
DEBUG_LOG(m_logger) << "!!! Clear Materials : sample time " << data.sampleTime;
|
||||
participant->setSanitationMaterial(0,
|
||||
std::vector<int>(),
|
||||
data.uniqueId(),
|
||||
data.sampleTime(),
|
||||
data.uniqueId,
|
||||
data.sampleTime,
|
||||
Qualification::NotAssigned,
|
||||
data.originatorEquipmentNumber()); // this is a deassociation so clear material
|
||||
data.originatorEquipmentNumber); // this is a deassociation so clear material
|
||||
}
|
||||
else
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "!!! Set Materials : equipment number " << data.equipmentNumber();
|
||||
DEBUG_LOG(m_logger) << "!!! Set Materials : sample time " << data.sampleTime();
|
||||
participant->setSanitationMaterial(data.sanitaryMaterialCount(),
|
||||
data.sanitaryMaterialStock(),
|
||||
data.uniqueId(),
|
||||
data.sampleTime(),
|
||||
static_cast<ParticipantManagement::Qualification>(data.qualification().underlying()),
|
||||
data.originatorEquipmentNumber());
|
||||
DEBUG_LOG(m_logger) << "!!! Set Materials : equipment number " << data.equipmentNumber;
|
||||
DEBUG_LOG(m_logger) << "!!! Set Materials : sample time " << data.sampleTime;
|
||||
participant->setSanitationMaterial(data.sanitaryMaterialCount,
|
||||
data.sanitaryMaterialStock,
|
||||
data.uniqueId,
|
||||
data.sampleTime,
|
||||
static_cast<ParticipantManagement::Qualification>(data.qualification),
|
||||
data.originatorEquipmentNumber);
|
||||
}
|
||||
participant->publishDynamicData();
|
||||
}
|
||||
|
||||
void ParticipantHandler::onParticipantSanitation(const TrainingAreaBase::ParticipantSanitation &data)
|
||||
{
|
||||
Participant *participant = participantByEquipmentNumber(data.equipmentNumber());
|
||||
Participant *participantOrig = participantByEquipmentNumber(data.originatorEquipmentNumber());
|
||||
Participant *participant = participantByEquipmentNumber(data.equipmentNumber);
|
||||
Participant *participantOrig = participantByEquipmentNumber(data.originatorEquipmentNumber);
|
||||
if (!participant)
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber();
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber;
|
||||
return;
|
||||
}
|
||||
int participantOrigId = data.originatorEquipmentNumber();
|
||||
int participantOrigId = data.originatorEquipmentNumber;
|
||||
if (participantOrig)
|
||||
participantOrigId = participantOrig->id();
|
||||
|
||||
if (data.qualification() == TrainingAreaBase::Qualification::NotDefined && data.proceduresTaken() == 0)
|
||||
if (data.qualification == TrainingAreaBase::Qualification::NotDefined && data.proceduresTaken == 0)
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "!!! Clear Sanitation = " << data.sampleTime();
|
||||
DEBUG_LOG(m_logger) << "!!! Clear Sanitation: equipNo = " << data.equipmentNumber();
|
||||
participant->setSanitationMaterial(0, std::vector<int>(), 0, data.sampleTime(), Qualification::NotAssigned, 0); // this is a deassociation so clear material
|
||||
DEBUG_LOG(m_logger) << "!!! Clear Sanitation = " << data.sampleTime;
|
||||
DEBUG_LOG(m_logger) << "!!! Clear Sanitation: equipNo = " << data.equipmentNumber;
|
||||
participant->setSanitationMaterial(0, std::vector<int>(), 0, data.sampleTime, Qualification::NotAssigned, 0); // this is a deassociation so clear material
|
||||
}
|
||||
else
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "!!! SetSanitation: sample time = " << data.sampleTime();
|
||||
DEBUG_LOG(m_logger) << "!!! SetSanitation: equipNo = " << data.equipmentNumber();
|
||||
participant->setSanitation(data.proceduresTaken(), data.sanitationResult(), data.sanitationEvaluation(), participantOrigId, data.qualification(), data.sampleTime());
|
||||
DEBUG_LOG(m_logger) << "!!! SetSanitation: sample time = " << data.sampleTime;
|
||||
DEBUG_LOG(m_logger) << "!!! SetSanitation: equipNo = " << data.equipmentNumber;
|
||||
participant->setSanitation(data.proceduresTaken, data.sanitationResult, data.sanitationEvaluation, participantOrigId, data.qualification, data.sampleTime);
|
||||
}
|
||||
participant->publishDynamicData();
|
||||
}
|
||||
@@ -549,67 +549,67 @@ void ParticipantHandler::onParticipantSanitation(const TrainingAreaBase::Partici
|
||||
void ParticipantHandler::onOperatorAction(const TrainingAreaBase::OperatorAction &data)
|
||||
{
|
||||
// maybe use other commands later?!
|
||||
if (data.action() != 8 && data.action() != 35)
|
||||
if (data.action != 8 && data.action != 35)
|
||||
return;
|
||||
|
||||
Participant *participant = participantByEquipmentNumber(data.equipmentNumber());
|
||||
Participant *participant = participantByEquipmentNumber(data.equipmentNumber);
|
||||
if (!participant)
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber();
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber;
|
||||
return;
|
||||
}
|
||||
|
||||
if (participant->setOperatorAction(data.action(), data.operatorId(), data.sampleTime()))
|
||||
if (participant->setOperatorAction(data.action, data.operatorId, data.sampleTime))
|
||||
participant->publishDynamicData();
|
||||
}
|
||||
|
||||
void ParticipantHandler::onEquipmentEvent(const TrainingAreaBase::EquipmentEvent &data)
|
||||
{
|
||||
// maybe use other commands later?!
|
||||
if (data.source().subDeviceId() != 14 || data.source().equipmentFunctionId() != 5)
|
||||
if (data.source.subDeviceId != 14 || data.source.equipmentFunctionId != 5)
|
||||
return;
|
||||
|
||||
if (data.code() == 1 || data.code() == 2) // 1: 9Liner 2: Transport
|
||||
if (data.code == 1 || data.code == 2) // 1: 9Liner 2: Transport
|
||||
{
|
||||
Participant *participant = participantByEquipmentNumber(data.equipmentNumber());
|
||||
Participant *participant = participantByEquipmentNumber(data.equipmentNumber);
|
||||
if (!participant)
|
||||
return;
|
||||
|
||||
if (participant->setEquipmentEvent(data.code(), data.sampleTime()))
|
||||
if (participant->setEquipmentEvent(data.code, data.sampleTime))
|
||||
participant->publishDynamicData();
|
||||
}
|
||||
}
|
||||
|
||||
void ParticipantHandler::onNewFunctionalAreaEntryChanged(const TrainingAreaBase::FunctionalAreaEntry &data)
|
||||
{
|
||||
Participant *participant = participantByEquipmentNumber(data.equipmentNumber());
|
||||
Participant *participant = participantByEquipmentNumber(data.equipmentNumber);
|
||||
|
||||
if (!participant)
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber();
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber;
|
||||
return;
|
||||
}
|
||||
|
||||
TrainingAreaBase::EquipmentPosition pos;
|
||||
pos.equipmentNumber(data.equipmentNumber());
|
||||
pos.sampleTime(data.sampleTime());
|
||||
Core::GeoPosition geoPos(data.position().lon(), data.position().lat(), 0);
|
||||
pos.position().position(geoPos);
|
||||
pos.equipmentNumber = data.equipmentNumber;
|
||||
pos.sampleTime = data.sampleTime;
|
||||
Core::GeoPosition geoPos(data.position.lon, data.position.lat, 0);
|
||||
pos.position.position = geoPos;
|
||||
if (participant->setPosition(pos))
|
||||
participant->publishPosition();
|
||||
|
||||
StateInformation oldState = youngestStateInformation(participant->dynamicParticipantData().stateHistory(), false);
|
||||
StateInformation oldState = youngestStateInformation(participant->dynamicParticipantData().stateHistory, false);
|
||||
TrainingAreaBase::EquipmentState state;
|
||||
state.equipmentNumber(data.equipmentNumber());
|
||||
state.originatorId(data.aesItemId());
|
||||
state.originatorType(ProjectDataManagement::StateChangeOriginator::FunctionalArea);
|
||||
state.sampleTime(data.sampleTime());
|
||||
state.vulnerabilityState(ProjectDataManagement::VulnerabilityState::VulnerabilityState_HitWithNoEffect); // no effect - it's an entry into a functional area
|
||||
state.vulnerabilityBits(oldState.vulnerabilityBits());
|
||||
state.vulnerabilityKindId(oldState.vulnerabilityKindId());
|
||||
state.vitality(oldState.vitality());
|
||||
state.equipmentNumber = data.equipmentNumber;
|
||||
state.originatorId = data.aesItemId;
|
||||
state.originatorType = ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_FunctionalArea;
|
||||
state.sampleTime = data.sampleTime;
|
||||
state.vulnerabilityState = ProjectDataManagement::VulnerabilityState::VulnerabilityState_HitWithNoEffect; // no effect - it's an entry into a functional area
|
||||
state.vulnerabilityBits = oldState.vulnerabilityBits;
|
||||
state.vulnerabilityKindId = oldState.vulnerabilityKindId;
|
||||
state.vitality = oldState.vitality;
|
||||
|
||||
participant->setState(state, data.aesItemId());
|
||||
participant->setState(state, data.aesItemId);
|
||||
participant->publishDynamicData();
|
||||
}
|
||||
|
||||
@@ -626,9 +626,9 @@ void ParticipantHandler::onHitLineInfoTimeout()
|
||||
auto it = m_hitLineInfoMap.begin();
|
||||
while (it != m_hitLineInfoMap.end())
|
||||
{
|
||||
if (!isOutdated(tNow, it.value().sampleTime()))
|
||||
if (!isOutdated(tNow, it.value().sampleTime))
|
||||
break;
|
||||
dts()->removeHitLineInfoByKey(it.value().id());
|
||||
dts()->removeHitLineInfoByKey(it.value().id);
|
||||
|
||||
it = m_hitLineInfoMap.erase(it);
|
||||
}
|
||||
@@ -636,11 +636,11 @@ void ParticipantHandler::onHitLineInfoTimeout()
|
||||
|
||||
void ParticipantHandler::setPosition(const ParticipantManagement::ParticipantPosition &data)
|
||||
{
|
||||
Participant *participant = participantById(data.participantId());
|
||||
Participant *participant = participantById(data.participantId);
|
||||
|
||||
if (!participant)
|
||||
{
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with id " << data.participantId();
|
||||
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with id " << data.participantId;
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -651,7 +651,7 @@ void ParticipantHandler::setHitlineInfoFromReplay(const HitLineInfo &data)
|
||||
{
|
||||
if (!dts()->publish(data))
|
||||
return;
|
||||
m_hitLineInfoMap.insert(data.id(), data);
|
||||
m_hitLineInfoMap.insert(data.id, data);
|
||||
}
|
||||
|
||||
void ParticipantHandler::setUASFromReplay(const UAS &data)
|
||||
@@ -687,43 +687,43 @@ void ParticipantHandler::updateLaserDesignation(DynamicParticipantData &data, co
|
||||
LOGGER_T m_logger = getLogger("ParticipantHandler.Laser");
|
||||
DEBUG_LOG(m_logger) << "-Update Laser Designation - Start ";
|
||||
|
||||
for (LaserDesignation &laserDesignation : data.designations())
|
||||
for (LaserDesignation &laserDesignation : data.designations)
|
||||
{
|
||||
if (laserDesignation.gearId() != newLaserDesignation.gearId())
|
||||
if (laserDesignation.gearId != newLaserDesignation.gearId)
|
||||
continue;
|
||||
|
||||
DEBUG_LOG(m_logger) << "-Update Laser Designation - Gear with id " << laserDesignation.gearId() << " found in designations";
|
||||
laserDesignation.code(newLaserDesignation.code());
|
||||
DEBUG_LOG(m_logger) << "-Update Laser Designation - Gear with id " << laserDesignation.gearId << " found in designations";
|
||||
laserDesignation.code = newLaserDesignation.code;
|
||||
|
||||
if (!qFuzzyIsNull(laserDesignation.outputPower()) && !qFuzzyIsNull(newLaserDesignation.spotLocation().lat())
|
||||
&& !qFuzzyIsNull(newLaserDesignation.spotLocation().lon()))
|
||||
laserDesignation.spotLocation(Core::GeoPosition(newLaserDesignation.spotLocation().lon(), newLaserDesignation.spotLocation().lat(), 0.0));
|
||||
if (!qFuzzyIsNull(laserDesignation.outputPower) && !qFuzzyIsNull(newLaserDesignation.spotLocation.lat)
|
||||
&& !qFuzzyIsNull(newLaserDesignation.spotLocation.lon))
|
||||
laserDesignation.spotLocation = Core::GeoPosition(newLaserDesignation.spotLocation.lon, newLaserDesignation.spotLocation.lat, 0.0);
|
||||
|
||||
// If Laser was on before and now is turned off, we have to reset spot Location
|
||||
if (!qFuzzyIsNull(laserDesignation.outputPower()) && qFuzzyIsNull(newLaserDesignation.outputPower()))
|
||||
laserDesignation.spotLocation(Core::GeoPosition(0.0, 0.0, 0.0));
|
||||
if (!qFuzzyIsNull(laserDesignation.outputPower) && qFuzzyIsNull(newLaserDesignation.outputPower))
|
||||
laserDesignation.spotLocation = Core::GeoPosition(0.0, 0.0, 0.0);
|
||||
|
||||
laserDesignation.outputPower(newLaserDesignation.outputPower());
|
||||
laserDesignation.outputPower = newLaserDesignation.outputPower;
|
||||
DEBUG_LOG(m_logger) << "-Update Laser Designation - Data updated, returning";
|
||||
return;
|
||||
}
|
||||
|
||||
DEBUG_LOG(m_logger) << "-Update Laser Designation - Gear with id " << newLaserDesignation.gearId() << " NOT found in designations";
|
||||
DEBUG_LOG(m_logger) << "-Update Laser Designation - Gear with id " << newLaserDesignation.gearId << " NOT found in designations";
|
||||
|
||||
int gearId = newLaserDesignation.gearId();
|
||||
auto it = std::find_if(data.gear().cbegin(), data.gear().cend(), [gearId](const GearInformation &gi) { return gearId == gi.gearId(); });
|
||||
if (it == data.gear().cend()) // No gear, no designation...
|
||||
int gearId = newLaserDesignation.gearId;
|
||||
auto it = std::find_if(data.gear.cbegin(), data.gear.cend(), [gearId](const GearInformation &gi) { return gearId == gi.gearId; });
|
||||
if (it == data.gear.cend()) // No gear, no designation...
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "-Update Laser Designation - Gear with id " << newLaserDesignation.gearId() << " NOT found in Gears";
|
||||
DEBUG_LOG(m_logger) << "-Update Laser Designation - Gear with id " << newLaserDesignation.gearId << " NOT found in Gears";
|
||||
return;
|
||||
}
|
||||
|
||||
DEBUG_LOG(m_logger) << "-Update Laser Designation - Gear with id " << newLaserDesignation.gearId() << " found in Gears";
|
||||
DEBUG_LOG(m_logger) << "-Update Laser Designation - Gear with id " << newLaserDesignation.gearId << " found in Gears";
|
||||
DEBUG_LOG(m_logger) << "-Update Laser Designation - Adding new designation";
|
||||
data.designations().emplace_back(newLaserDesignation.gearId(),
|
||||
Core::GeoPosition(newLaserDesignation.spotLocation().lon(), newLaserDesignation.spotLocation().lat(), 0.0),
|
||||
newLaserDesignation.code(),
|
||||
newLaserDesignation.outputPower());
|
||||
data.designations.emplace_back(newLaserDesignation.gearId,
|
||||
Core::GeoPosition(newLaserDesignation.spotLocation.lon, newLaserDesignation.spotLocation.lat, 0.0),
|
||||
newLaserDesignation.code,
|
||||
newLaserDesignation.outputPower);
|
||||
}
|
||||
|
||||
void ParticipantHandler::updateLaserDesignation(DynamicParticipantData &dataInOut, const Buildings::BuildingHitLineInfo &newLaserDesignation)
|
||||
@@ -733,28 +733,28 @@ void ParticipantHandler::updateLaserDesignation(DynamicParticipantData &dataInOu
|
||||
// Mehrere Designatoren pro Teilnehmer werden nicht unterstützt.
|
||||
DEBUG_LOG(m_logger) << "-Update Laser Designation by Building Hitline Info";
|
||||
|
||||
for (LaserDesignation &laserDesignation : dataInOut.designations())
|
||||
for (LaserDesignation &laserDesignation : dataInOut.designations)
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "-Update Laser Designation by Building Hitline Info - Updating (first) Designation with GearId " << laserDesignation.gearId();
|
||||
laserDesignation.outputPower(1.0);
|
||||
laserDesignation.spotLocation(newLaserDesignation.buildingPos());
|
||||
DEBUG_LOG(m_logger) << "-Update Laser Designation by Building Hitline Info - Updating (first) Designation with GearId " << laserDesignation.gearId;
|
||||
laserDesignation.outputPower = 1.0;
|
||||
laserDesignation.spotLocation = newLaserDesignation.buildingPos;
|
||||
return;
|
||||
}
|
||||
|
||||
QSet<int> ldGearTypes{1043}; // Need Property for LTD...
|
||||
auto it = std::find_if(dataInOut.gear().cbegin(), dataInOut.gear().cend(), [ldGearTypes](const GearInformation &gi) { return ldGearTypes.contains(gi.gearTypeId()); });
|
||||
if (it != dataInOut.gear().cend())
|
||||
auto it = std::find_if(dataInOut.gear.cbegin(), dataInOut.gear.cend(), [ldGearTypes](const GearInformation &gi) { return ldGearTypes.contains(gi.gearTypeId); });
|
||||
if (it != dataInOut.gear.cend())
|
||||
{
|
||||
LaserDesignation ld;
|
||||
ld.gearId() = it->gearId();
|
||||
ld.code() = 0;
|
||||
ld.spotLocation() = newLaserDesignation.buildingPos();
|
||||
ld.outputPower(1.0);
|
||||
dataInOut.designations().emplace_back(ld);
|
||||
ld.gearId = it->gearId;
|
||||
ld.code = 0;
|
||||
ld.spotLocation = newLaserDesignation.buildingPos;
|
||||
ld.outputPower = 1.0;
|
||||
dataInOut.designations.emplace_back(ld);
|
||||
ERROR_LOG(m_logger) << "-Update Laser Designation by Building Hitline Info - Added Designation";
|
||||
}
|
||||
ERROR_LOG(m_logger) << "-Update Laser Designation by Building Hitline Info - No laserDesignation available participantId="
|
||||
<< newLaserDesignation.originatorParticipantId();
|
||||
<< newLaserDesignation.originatorParticipantId;
|
||||
}
|
||||
|
||||
void ParticipantHandler::removeLaserDesignation(DynamicParticipantData &data, qint32 gearId)
|
||||
@@ -762,17 +762,17 @@ void ParticipantHandler::removeLaserDesignation(DynamicParticipantData &data, qi
|
||||
LOGGER_T m_logger = getLogger("ParticipantHandler.Laser");
|
||||
|
||||
DEBUG_LOG(m_logger) << "-Remove Laser Designation: Start";
|
||||
auto validationFunction = [gearId](ParticipantManagement::LaserDesignation laserDesignation) { return laserDesignation.gearId() == gearId; };
|
||||
auto eraseIterator = std::find_if(data.designations().begin(), data.designations().end(), validationFunction);
|
||||
auto validationFunction = [gearId](ParticipantManagement::LaserDesignation laserDesignation) { return laserDesignation.gearId == gearId; };
|
||||
auto eraseIterator = std::find_if(data.designations.begin(), data.designations.end(), validationFunction);
|
||||
|
||||
if (eraseIterator == data.designations().end())
|
||||
if (eraseIterator == data.designations.end())
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "-Remove Laser Designation: GearId NOT found";
|
||||
return;
|
||||
}
|
||||
|
||||
DEBUG_LOG(m_logger) << "-Remove Laser Designation: Removing Designation";
|
||||
data.designations().erase(eraseIterator);
|
||||
data.designations.erase(eraseIterator);
|
||||
}
|
||||
|
||||
} // namespace ParticipantHandling
|
||||
|
||||
+2
-2
@@ -151,10 +151,10 @@ class ParticipantHandler
|
||||
|
||||
static bool isSupportTypeClass(const TypeClass &typeClass);
|
||||
// t - 11min <= sampleTime
|
||||
template <typename T> inline bool isTelegramOutdated(const T &tele) const { return isSampleTimeOutdated(tele.sampleTime()); }
|
||||
template <typename T> inline bool isTelegramOutdated(const T &tele) const { return isSampleTimeOutdated(tele.sampleTime); }
|
||||
virtual bool isSampleTimeOutdated(qint64 sampleTime) const;
|
||||
// sampleTime > t + 1min
|
||||
template <typename T> inline bool isTelegramInFuture(const T &tele) const { return isSampleTimeInFuture(tele.sampleTime()); }
|
||||
template <typename T> inline bool isTelegramInFuture(const T &tele) const { return isSampleTimeInFuture(tele.sampleTime); }
|
||||
virtual bool isSampleTimeInFuture(qint64 sampleTime) const;
|
||||
|
||||
protected:
|
||||
|
||||
+338
-338
File diff suppressed because it is too large.
Load diff
+34
-34
@@ -217,7 +217,7 @@ void ProxyListener::onLaserDesignationChanged(const TrainingAreaBase::LaserDesig
|
||||
if (modType == DataModification::eRemoved)
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "Got no laser designation data: " << data;
|
||||
emit laserDesignationRemoved(data.equipmentNumber(), data.gearId());
|
||||
emit laserDesignationRemoved(data.equipmentNumber, data.gearId);
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -264,25 +264,25 @@ void ProxyListener::onUASStatusChanged(const TrainingAreaBase::UASStatus &data,
|
||||
|
||||
|
||||
m_mainHandler->ddsHandler()->dtc()->waitForHistoricalDataParticipant(3000);
|
||||
int participantId = m_mainHandler->ddsHandler()->dtc()->participantIdByEquipmentNumber(data.equipmentNumber());
|
||||
int participantId = m_mainHandler->ddsHandler()->dtc()->participantIdByEquipmentNumber(data.equipmentNumber);
|
||||
|
||||
if (participantId <= 0)
|
||||
return;
|
||||
const auto uas = m_mainHandler->ddsHandler()->dtc()->getUasByParticipantId(participantId, m_mainHandler->exerciseId());
|
||||
|
||||
if (uas.id() <= 0)
|
||||
if (uas.id <= 0)
|
||||
return;
|
||||
//new PPM Telegram
|
||||
UASRadioLinkConnectionStatus newState;
|
||||
newState.id(uas.id());
|
||||
newState.uasState(data.uasState());
|
||||
newState.id = uas.id;
|
||||
newState.uasState = data.uasState;
|
||||
DEBUG_LOG(m_logger) << "Publish new UAS State " << newState;
|
||||
m_mainHandler->ddsHandler()->exAnyDts()->publish(newState);
|
||||
}
|
||||
|
||||
void ProxyListener::onUASMissionStatusChanged(const TrainingAreaBase::UASMissionStatus &data, DataModification modType)
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "currentTask = " << (int)data.currentTask().underlying() << ", currentMissionName = " << data.currentMissionName() << ", name of ended mission: " << data.missionEnded();
|
||||
DEBUG_LOG(m_logger) << "currentTask = " << (int)data.currentTask << ", currentMissionName = " << data.currentMissionName << ", name of ended mission: " << data.missionEnded;
|
||||
/*
|
||||
was wenn random mehrfach hintereinander loiter gesendet wird??
|
||||
dann überspringt er eine action! der tab darf also nur senden wenn wirklich ein state change kam
|
||||
@@ -295,25 +295,25 @@ void ProxyListener::onUASMissionStatusChanged(const TrainingAreaBase::UASMission
|
||||
return;
|
||||
}
|
||||
|
||||
if (!data.currentMissionName().empty() || data.currentTask().underlying() != ProjectDataManagement::UasActionTask::Loiter || data.missionEnded().empty())
|
||||
if (!data.currentMissionName.empty() || data.currentTask != ProjectDataManagement::UasActionTask::Loiter || data.missionEnded.empty())
|
||||
{
|
||||
//DEBUG As this will happen a lot
|
||||
DEBUG_LOG(m_logger) << "not fulfilling current mission ("<<data.currentMissionName()<<") action because either a mission is still active or current task ("<<(int)data.currentTask().underlying()<<") is not Loiter or mission not ended ("<< data.missionEnded() << (data.missionEnded().empty() ? " [NOT ENDED]" : " [ ENDED ]")<<")";
|
||||
DEBUG_LOG(m_logger) << "not fulfilling current mission ("<<data.currentMissionName<<") action because either a mission is still active or current task ("<<(int)data.currentTask<<") is not Loiter or mission not ended ("<< data.missionEnded << (data.missionEnded.empty() ? " [NOT ENDED]" : " [ ENDED ]")<<")";
|
||||
return;
|
||||
}
|
||||
|
||||
m_mainHandler->ddsHandler()->dtc()->waitForHistoricalDataParticipant(3000);
|
||||
const int participantId = m_mainHandler->ddsHandler()->dtc()->participantIdByEquipmentNumber(data.equipmentNumber());
|
||||
const int participantId = m_mainHandler->ddsHandler()->dtc()->participantIdByEquipmentNumber(data.equipmentNumber);
|
||||
if (participantId <= 0)
|
||||
{
|
||||
ERROR_LOG(m_logger) << "participant for eqid " << data.equipmentNumber() << " not found - unable to fulfill current mission action";
|
||||
ERROR_LOG(m_logger) << "participant for eqid " << data.equipmentNumber << " not found - unable to fulfill current mission action";
|
||||
return;
|
||||
}
|
||||
|
||||
QTimer::singleShot(1000, [this, participantId, data]() // give tab plugin time to clean stuff up before sending new missions (by marking an action as fulfilled)
|
||||
{
|
||||
// mission empty & task = loiter? mission done, run next mission (by setting current mission's current action as fulfilled, which will trigger the next action automatically (see ces))
|
||||
if (!m_mainHandler->missionPlanHandler()->setCurrentMissionActionFulfilled(participantId, QString::fromStdString(data.missionEnded())))
|
||||
if (!m_mainHandler->missionPlanHandler()->setCurrentMissionActionFulfilled(participantId, QString::fromStdString(data.missionEnded)))
|
||||
{
|
||||
ERROR_LOG(m_logger) << "setCurrentMissionActionFulfilled didn't work out";
|
||||
return;
|
||||
@@ -351,13 +351,13 @@ Core::FunctionReplyObject ProxyListener::demandVulnerabilityStateChange(const rt
|
||||
if (!m_mainHandler->tabFtc()->demandVulnerabilityStateChangeRequest(req, this))
|
||||
return Core::FunctionReplyObject(tr_lts("dds", "Error passing the Vulnerability state change request to the proxy"));
|
||||
|
||||
const int requestId = req.requestId();
|
||||
const int requestId = req.requestId;
|
||||
auto cb = [this, requestId]()
|
||||
{
|
||||
INFO_LOG(m_logger) << "VulnerabilityStateChange timeout for " << requestId;
|
||||
onDemandVulnerabilityStateChangeReply(Core::FunctionReplyObject(requestId, tr_lts("dds", "Timeout while waiting for the proxy")));
|
||||
};
|
||||
addToTrainingAreaRequests(cb, req.requestId(), cookie);
|
||||
addToTrainingAreaRequests(cb, req.requestId, cookie);
|
||||
|
||||
return Core::FunctionReplyObject();
|
||||
}
|
||||
@@ -374,17 +374,17 @@ void ProxyListener::onDemandVulnerabilityStateChangeReply(const Core::FunctionRe
|
||||
Core::FunctionReplyObject ProxyListener::sendModifyUasStateRequest(const rti::core::SampleIdentity &cookie,
|
||||
const TrainingAreaBase::SendModifyUasStateRequest &req)
|
||||
{
|
||||
DEBUG_LOG(m_logger) << " -- [ProxyListener] sendModifyUasStateRequest uasId: " << req.uasId();
|
||||
DEBUG_LOG(m_logger) << " -- [ProxyListener] sendModifyUasStateRequest uasId: " << req.uasId;
|
||||
if (!m_mainHandler->tabFtc()->sendModifyUasStateRequest(req, this))
|
||||
return Core::FunctionReplyObject(tr_lts("dds", "Error passing the UAS state change request to the proxy"));
|
||||
|
||||
const int requestId = req.requestId();
|
||||
const int requestId = req.requestId;
|
||||
auto cb = [this, requestId]()
|
||||
{
|
||||
INFO_LOG(m_logger) << "ModifyUasState timeout for " << requestId;
|
||||
onSendModifyUasStateReply(Core::FunctionReplyObject(requestId, tr_lts("dds", "Timeout while waiting for the proxy")));
|
||||
};
|
||||
addToTrainingAreaRequests(cb, req.requestId(), cookie);
|
||||
addToTrainingAreaRequests(cb, req.requestId, cookie);
|
||||
|
||||
return Core::FunctionReplyObject();
|
||||
}
|
||||
@@ -404,13 +404,13 @@ Core::FunctionReplyObject ProxyListener::demandInitRequest(const rti::core::Samp
|
||||
if (!m_mainHandler->tabFtc()->demandInitRequest(req, this))
|
||||
return Core::FunctionReplyObject(tr_lts("dds", "Error passing the INIT request to the proxy"));
|
||||
|
||||
const int requestId = req.requestId();
|
||||
const int requestId = req.requestId;
|
||||
auto cb = [this, requestId]()
|
||||
{
|
||||
INFO_LOG(m_logger) << "DemandInit timeout for " << requestId;
|
||||
onDemandInitReply(Core::FunctionReplyObject(requestId, tr_lts("dds", "Timeout while waiting for the proxy")));
|
||||
};
|
||||
addToTrainingAreaRequests(cb, req.requestId(), cookie);
|
||||
addToTrainingAreaRequests(cb, req.requestId, cookie);
|
||||
|
||||
return Core::FunctionReplyObject();
|
||||
}
|
||||
@@ -431,13 +431,13 @@ Core::FunctionReplyObject ProxyListener::sendEquipmentMessage(const rti::core::S
|
||||
if (!m_mainHandler->tabFtc()->sendEquipmentMessageRequest(req, this))
|
||||
return Core::FunctionReplyObject(tr_lts("dds", "Error passing SendMessage request to the proxy"));
|
||||
|
||||
const int requestId = req.requestId();
|
||||
const int requestId = req.requestId;
|
||||
auto cb = [this, requestId]()
|
||||
{
|
||||
INFO_LOG(m_logger) << "SendMessage timeout for " << requestId;
|
||||
onSendEquipmentMessageReply(Core::FunctionReplyObject(requestId, tr_lts("dds", "Timeout while waiting for the proxy")));
|
||||
};
|
||||
addToTrainingAreaRequests(cb, req.requestId(), cookie);
|
||||
addToTrainingAreaRequests(cb, req.requestId, cookie);
|
||||
|
||||
return Core::FunctionReplyObject();
|
||||
}
|
||||
@@ -456,17 +456,17 @@ Core::FunctionReplyObject ProxyListener::sendParticipantModeRequest(const rti::c
|
||||
const TrainingAreaBase::SendParticipantModeRequest &req)
|
||||
{
|
||||
if (!m_mainHandler->tabFtc()->sendParticipantModeRequest(req, this))
|
||||
return Core::FunctionReplyObject(req.participantId(), tr_lts("dds", "Error passing the INIT request to the proxy"));
|
||||
return Core::FunctionReplyObject(req.participantId, tr_lts("dds", "Error passing the INIT request to the proxy"));
|
||||
|
||||
const int requestId = req.requestId();
|
||||
const int requestId = req.requestId;
|
||||
auto cb = [this, requestId]()
|
||||
{
|
||||
INFO_LOG(m_logger) << "SendParticipantMode timeout for " << requestId;
|
||||
onSendParticipantModeReply(Core::FunctionReplyObject(requestId, tr_lts("dds", "Timeout while waiting for the proxy")));
|
||||
};
|
||||
addToTrainingAreaRequests(cb, req.requestId(), cookie);
|
||||
addToTrainingAreaRequests(cb, req.requestId, cookie);
|
||||
|
||||
return Core::FunctionReplyObject(req.participantId());
|
||||
return Core::FunctionReplyObject(req.participantId);
|
||||
}
|
||||
|
||||
void ProxyListener::onSendParticipantModeReply(const Core::FunctionReplyObject &replyObject)
|
||||
@@ -481,15 +481,15 @@ void ProxyListener::onSendParticipantModeReply(const Core::FunctionReplyObject &
|
||||
Core::FunctionReplyObject ProxyListener::sendSetSanitationRequest(const rti::core::SampleIdentity &cookie, const TrainingAreaBase::SendSetSanitationRequest &req)
|
||||
{
|
||||
if (!m_mainHandler->tabFtc()->sendSetSanitationRequest(req, this))
|
||||
return Core::FunctionReplyObject(req.participantId(), tr_lts("dds", "Error passing the SetSanitation request to the proxy"));
|
||||
const int requestId = req.requestId();
|
||||
return Core::FunctionReplyObject(req.participantId, tr_lts("dds", "Error passing the SetSanitation request to the proxy"));
|
||||
const int requestId = req.requestId;
|
||||
auto cb = [this, requestId]()
|
||||
{
|
||||
INFO_LOG(m_logger) << "sendSetSanitationRequest timeout for " << requestId;
|
||||
onSendSetSanitationReply(Core::FunctionReplyObject(requestId, tr_lts("dds", "Timeout while waiting for the proxy")));
|
||||
};
|
||||
addToTrainingAreaRequests(cb, req.requestId(), cookie);
|
||||
return Core::FunctionReplyObject(req.participantId());
|
||||
addToTrainingAreaRequests(cb, req.requestId, cookie);
|
||||
return Core::FunctionReplyObject(req.participantId);
|
||||
}
|
||||
|
||||
void ProxyListener::onSendSetSanitationReply(const Core::FunctionReplyObject &replyObject)
|
||||
@@ -504,15 +504,15 @@ void ProxyListener::onSendSetSanitationReply(const Core::FunctionReplyObject &re
|
||||
Core::FunctionReplyObject ProxyListener::selectiveReammunitionRequest(const rti::core::SampleIdentity &cookie, const TrainingAreaBase::SendSelectiveReammunitionRequest &req)
|
||||
{
|
||||
if (!m_mainHandler->tabFtc()->sendSelectiveReammunitionRequest(req, this))
|
||||
return Core::FunctionReplyObject(req.participantId(), tr_lts("dds", "Error passing the SendSelectiveReammunition request to the proxy"));
|
||||
const int requestId = req.requestId();
|
||||
return Core::FunctionReplyObject(req.participantId, tr_lts("dds", "Error passing the SendSelectiveReammunition request to the proxy"));
|
||||
const int requestId = req.requestId;
|
||||
auto cb = [this, requestId]()
|
||||
{
|
||||
INFO_LOG(m_logger) << "selectiveReammunitionRequest timeout for " << requestId;
|
||||
onSendSelectiveReammunitionReply(Core::FunctionReplyObject(requestId, tr_lts("dds", "Timeout while waiting for the proxy")));
|
||||
};
|
||||
addToTrainingAreaRequests(cb, req.requestId(), cookie);
|
||||
return Core::FunctionReplyObject(req.participantId());
|
||||
addToTrainingAreaRequests(cb, req.requestId, cookie);
|
||||
return Core::FunctionReplyObject(req.participantId);
|
||||
}
|
||||
|
||||
void ProxyListener::onSendSelectiveReammunitionReply(const Core::FunctionReplyObject &replyObject)
|
||||
@@ -531,13 +531,13 @@ Core::FunctionReplyObject ProxyListener::sendOcCommandRequest(const rti::core::S
|
||||
if (!m_mainHandler->tabFtc()->sendOcCommandRequest(req, this))
|
||||
return Core::FunctionReplyObject(tr_lts("dds", "Error passing the OcCommand request to the proxy"));
|
||||
|
||||
const int requestId = req.requestId();
|
||||
const int requestId = req.requestId;
|
||||
auto cb = [this, requestId]()
|
||||
{
|
||||
INFO_LOG(m_logger) << "SendOcCommand timeout for " << requestId;
|
||||
onSendOcCommandReply(Core::FunctionReplyObject(requestId, tr_lts("dds", "Timeout while waiting for the proxy")));
|
||||
};
|
||||
addToTrainingAreaRequests(cb, req.requestId(), cookie);
|
||||
addToTrainingAreaRequests(cb, req.requestId, cookie);
|
||||
|
||||
return Core::FunctionReplyObject();
|
||||
}
|
||||
|
||||
+31
-31
@@ -80,13 +80,13 @@ void UnitPositionCalculator::onPositionChanged(int participantId, int64_t positi
|
||||
DEBUG_LOG(m_logger) << "Position for participant " << participantId << " changed to "
|
||||
<< pos << " (" << positionTime / 1000 << "s)";
|
||||
CalculatedUnitPosition &data = getParticipant(participantId);
|
||||
if (data.sampleTimeLeader() >= positionTime)
|
||||
if (data.sampleTimeLeader >= positionTime)
|
||||
return;
|
||||
|
||||
data.sampleTimeCenter(positionTime);
|
||||
data.sampleTimeLeader(positionTime);
|
||||
data.positionCenter(pos);
|
||||
data.positionLeader(pos);
|
||||
data.sampleTimeCenter = positionTime;
|
||||
data.sampleTimeLeader = positionTime;
|
||||
data.positionCenter = pos;
|
||||
data.positionLeader = pos;
|
||||
m_bSomethingChangedSinceLastCalculation = true;
|
||||
}
|
||||
|
||||
@@ -122,10 +122,10 @@ UnitPositionCalculator::CalculatedUnitPosition &UnitPositionCalculator::getParti
|
||||
DEBUG_LOG(m_logger) << "No information for participant " << participantId << " - creating dummy data";
|
||||
|
||||
CalculatedUnitPosition data;
|
||||
data.participantId(participantId);
|
||||
data.participantId = participantId;
|
||||
static const Core::GeoPosition s_invalidPos(std::nan(""), std::nan(""), std::nan(""));
|
||||
data.positionCenter(s_invalidPos);
|
||||
data.positionLeader(s_invalidPos);
|
||||
data.positionCenter = s_invalidPos;
|
||||
data.positionLeader = s_invalidPos;
|
||||
it = m_participantData.insert({participantId, std::move(data)}).first;
|
||||
}
|
||||
return it->second;
|
||||
@@ -174,12 +174,12 @@ UnitPositionCalculator::Result UnitPositionCalculator::doCalculation(std::unorde
|
||||
for (const auto &data : participantData)
|
||||
{
|
||||
const int superiorId = data.second.superiorId;
|
||||
const int participantId = data.second.participantId();
|
||||
const int participantId = data.second.participantId;
|
||||
DEBUG_LOG(logger) << "Participant " << participantId << " has superior " << superiorId;
|
||||
if (superiorId == 0 || participantData.find(superiorId) == participantData.end())
|
||||
{
|
||||
DEBUG_LOG(logger) << "Participant " << participantId << " is a toplevel participant";
|
||||
topLevelIds.push_back(data.second.participantId());
|
||||
topLevelIds.push_back(data.second.participantId);
|
||||
}
|
||||
}
|
||||
// TODO: check for correct (non-cyclic) hierarchy?
|
||||
@@ -214,13 +214,13 @@ void UnitPositionCalculator::calculatePosition(int participantId,
|
||||
if (data.inferiorIds.size() == 0)
|
||||
{
|
||||
DEBUG_LOG(logger) << dbgLvlSpaces << "Participant " << participantId
|
||||
<< " is a leaf: " << data.positionCenter()
|
||||
<< " (" << data.sampleTimeCenter() / 1000 << "s)";
|
||||
<< " is a leaf: " << data.positionCenter
|
||||
<< " (" << data.sampleTimeCenter / 1000 << "s)";
|
||||
return;
|
||||
}
|
||||
|
||||
data.positionCenter(s_invalidPos);
|
||||
data.positionLeader(s_invalidPos);
|
||||
data.positionCenter = s_invalidPos;
|
||||
data.positionLeader = s_invalidPos;
|
||||
|
||||
// calculate position for inferiors
|
||||
DEBUG_LOG(logger) << dbgLvlSpaces << "Participant " << participantId << ": Start calculating child positions";
|
||||
@@ -249,15 +249,15 @@ void UnitPositionCalculator::calculatePosition(int participantId,
|
||||
|
||||
const CalculatedUnitPosition &child = itChild->second;
|
||||
// older than 10 minutes -> ignore
|
||||
if (LtsUtils::isPositionTimeOutdated(currentTime, child.sampleTimeCenter()))
|
||||
if (LtsUtils::isPositionTimeOutdated(currentTime, child.sampleTimeCenter))
|
||||
{
|
||||
DEBUG_LOG(logger) << dbgLvlSpaces << "Child " << inferiorId << ": position out-of-date - ignoring";
|
||||
continue;
|
||||
}
|
||||
|
||||
// invalid position -> ignore
|
||||
if (std::isnan(child.positionCenter().lon()) ||
|
||||
std::isnan(child.positionCenter().lat()))
|
||||
if (std::isnan(child.positionCenter.lon) ||
|
||||
std::isnan(child.positionCenter.lat))
|
||||
{
|
||||
DEBUG_LOG(logger) << dbgLvlSpaces << "Child " << inferiorId << ": has invalid position - ignoring";
|
||||
continue;
|
||||
@@ -266,36 +266,36 @@ void UnitPositionCalculator::calculatePosition(int participantId,
|
||||
if (bFirst)
|
||||
{
|
||||
bFirst = false;
|
||||
data.positionLeader(child.positionLeader());
|
||||
data.sampleTimeLeader(child.sampleTimeLeader());
|
||||
data.positionLeader = child.positionLeader;
|
||||
data.sampleTimeLeader = child.sampleTimeLeader;
|
||||
}
|
||||
|
||||
const auto utm = LtsCoordTrans::UtmCoordinate::fromGeographic(child.positionCenter().lon(),
|
||||
child.positionCenter().lat(),
|
||||
const auto utm = LtsCoordTrans::UtmCoordinate::fromGeographic(child.positionCenter.lon,
|
||||
child.positionCenter.lat,
|
||||
utmZone);
|
||||
if (utmZone == -1)
|
||||
utmZone = utm.zone;
|
||||
|
||||
pos += LtsUtils::QPoint3D(utm.x, utm.y, child.positionCenter().z());
|
||||
if (child.sampleTimeCenter() > childPositionTime)
|
||||
childPositionTime = child.sampleTimeCenter();
|
||||
pos += LtsUtils::QPoint3D(utm.x, utm.y, child.positionCenter.z);
|
||||
if (child.sampleTimeCenter > childPositionTime)
|
||||
childPositionTime = child.sampleTimeCenter;
|
||||
|
||||
++childCount;
|
||||
}
|
||||
|
||||
data.sampleTimeCenter(childPositionTime);
|
||||
data.sampleTimeCenter = childPositionTime;
|
||||
if (childCount > 0)
|
||||
{
|
||||
pos /= childCount;
|
||||
const LtsCoordTrans::UtmCoordinate utm(utmZone, pos.x(), pos.y(),true);
|
||||
const QPointF lonLat = utm.geographic();
|
||||
data.positionCenter(Core::GeoPosition(lonLat.x(), lonLat.y(), pos.z()));
|
||||
data.positionCenter = Core::GeoPosition(lonLat.x(), lonLat.y(), pos.z());
|
||||
}
|
||||
DEBUG_LOG(logger) << dbgLvlSpaces
|
||||
<< "Participant " << participantId
|
||||
<< ": Mean position: " << data.positionCenter()
|
||||
<< ": Mean position: " << data.positionCenter
|
||||
<< " #relavant children: " << childCount
|
||||
<< " (" << data.sampleTimeCenter() / 1000 << "s)";
|
||||
<< " (" << data.sampleTimeCenter / 1000 << "s)";
|
||||
|
||||
result.push_back(std::move(data));
|
||||
}
|
||||
@@ -307,7 +307,7 @@ void UnitPositionCalculator::onCalculationDone()
|
||||
auto dts = m_participantHandler->dts();
|
||||
for (const auto &pos : calculatedPositions)
|
||||
{
|
||||
auto it = m_publishedPositionData.find(pos.participantId());
|
||||
auto it = m_publishedPositionData.find(pos.participantId);
|
||||
if (it != m_publishedPositionData.end())
|
||||
{
|
||||
ParticipantManagement::UnitPosition &up = it->second;
|
||||
@@ -315,13 +315,13 @@ void UnitPositionCalculator::onCalculationDone()
|
||||
if (up == pos)
|
||||
continue;
|
||||
// nan == nan is always false, have to check it on our own
|
||||
if (std::isnan(up.positionCenter().lat()) && std::isnan(pos.positionCenter().lat()))
|
||||
if (std::isnan(up.positionCenter.lat) && std::isnan(pos.positionCenter.lat))
|
||||
continue;
|
||||
up = pos;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_publishedPositionData.insert(std::make_pair(pos.participantId(), pos));
|
||||
m_publishedPositionData.insert(std::make_pair(pos.participantId, pos));
|
||||
}
|
||||
dts->publish(pos);
|
||||
}
|
||||
|
||||
+22
-22
@@ -11,26 +11,26 @@
|
||||
bool ParticipantManagement::PartyHandling::Party::hasChanges(const ParticipantManagement::Party &request,
|
||||
const bool bIgnoreIsUsedBy)
|
||||
{
|
||||
const QString requestProperties = QString::fromStdString(request.properties());
|
||||
bool hasChanges = request.color() != m_data.color
|
||||
|| request.fadingColor() != m_data.fadingColor
|
||||
|| request.name() != m_data.name.toStdString()
|
||||
|| request.hlaForceIdentifier().underlying() != m_data.hlaForceIdentifier
|
||||
|| request.role() != m_data.roleId
|
||||
const QString requestProperties = QString::fromStdString(request.properties);
|
||||
bool hasChanges = request.color != m_data.color
|
||||
|| request.fadingColor != m_data.fadingColor
|
||||
|| request.name != m_data.name.toStdString()
|
||||
|| static_cast<int>(request.hlaForceIdentifier) != m_data.hlaForceIdentifier
|
||||
|| request.role != m_data.roleId
|
||||
|| requestProperties != m_data.properties;
|
||||
if (!bIgnoreIsUsedBy && !hasChanges)
|
||||
hasChanges = request.isUsedBy() != m_data.isUsedBy;
|
||||
hasChanges = request.isUsedBy != m_data.isUsedBy;
|
||||
|
||||
if (hasChanges)
|
||||
{
|
||||
m_data.color = request.color();
|
||||
m_data.fadingColor = request.fadingColor();
|
||||
m_data.name = QString::fromStdString(request.name());
|
||||
m_data.roleId = request.role();
|
||||
m_data.hlaForceIdentifier = request.hlaForceIdentifier().underlying();
|
||||
m_data.color = request.color;
|
||||
m_data.fadingColor = request.fadingColor;
|
||||
m_data.name = QString::fromStdString(request.name);
|
||||
m_data.roleId = request.role;
|
||||
m_data.hlaForceIdentifier = static_cast<int>(request.hlaForceIdentifier);
|
||||
m_data.properties = requestProperties;
|
||||
if (!bIgnoreIsUsedBy)
|
||||
m_data.isUsedBy = request.isUsedBy();
|
||||
m_data.isUsedBy = request.isUsedBy;
|
||||
}
|
||||
|
||||
return hasChanges;
|
||||
@@ -45,15 +45,15 @@ ParticipantManagement::Party ParticipantManagement::PartyHandling::Party::toDdsP
|
||||
{
|
||||
ParticipantManagement::Party result;
|
||||
|
||||
result.id(id());
|
||||
result.color(m_data.color);
|
||||
result.fadingColor(m_data.fadingColor);
|
||||
result.name(m_data.name.toStdString());
|
||||
result.role(m_data.roleId);
|
||||
result.hlaForceIdentifier(static_cast<HlaForceIdentifierEnum>(m_data.hlaForceIdentifier));
|
||||
result.isUsedBy(m_data.isUsedBy);
|
||||
result.sampleTime(QDateTime::currentMSecsSinceEpoch());
|
||||
result.properties(m_data.properties.toStdString());
|
||||
result.id = id();
|
||||
result.color = m_data.color;
|
||||
result.fadingColor = m_data.fadingColor;
|
||||
result.name = m_data.name.toStdString();
|
||||
result.role = m_data.roleId;
|
||||
result.hlaForceIdentifier = static_cast<HlaForceIdentifierEnum>(m_data.hlaForceIdentifier);
|
||||
result.isUsedBy = m_data.isUsedBy;
|
||||
result.sampleTime = QDateTime::currentMSecsSinceEpoch();
|
||||
result.properties = m_data.properties.toStdString();
|
||||
|
||||
return result;
|
||||
}
|
||||
+32
-32
@@ -93,7 +93,7 @@ void PartyHandling::PartyHandler::resetAdlerProperties( QString &properties, con
|
||||
if (connectState != ParticipantManagement::ConnectState::Disconnected)
|
||||
{
|
||||
QJsonObject propAdler = obj[QStringLiteral("Adler")].toObject();
|
||||
propAdler[QStringLiteral("saaConnectedState")] = ParticipantManagement::ConnectState::Disconnected;
|
||||
propAdler[QStringLiteral("saaConnectedState")] = static_cast<int>(ParticipantManagement::ConnectState::Disconnected);
|
||||
obj[QStringLiteral("Adler")] = propAdler;
|
||||
const QByteArray propertiesStr = QJsonDocument(obj).toJson(QJsonDocument::Compact);
|
||||
properties = QString::fromStdString(propertiesStr.data());
|
||||
@@ -149,11 +149,11 @@ void PartyHandling::PartyHandler::onModifyPartyDataRequest(const rti::core::Samp
|
||||
Core::FunctionReplyObject PartyHandling::PartyHandler::modifyPartyDataRequest(const ParticipantManagement::Party &request)
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "onModifyPartyDataRequest: " << request;
|
||||
Party *partyToPublish = m_parties.value(request.id());
|
||||
Party *partyToPublish = m_parties.value(request.id);
|
||||
|
||||
if (!partyToPublish && request.id() >= 0)
|
||||
return Core::FunctionReplyObject(request.id(), tr_lts("dds", "Could not modify party with id %1, because no party with that id exists"))
|
||||
.arg(request.id());
|
||||
if (!partyToPublish && request.id >= 0)
|
||||
return Core::FunctionReplyObject(request.id, tr_lts("dds", "Could not modify party with id %1, because no party with that id exists"))
|
||||
.arg(request.id);
|
||||
|
||||
if (!partyToPublish) // create new party
|
||||
{
|
||||
@@ -162,19 +162,19 @@ Core::FunctionReplyObject PartyHandling::PartyHandler::modifyPartyDataRequest(co
|
||||
// insert into database
|
||||
Database::PpmParty newDbParty;
|
||||
|
||||
newDbParty.color = request.color();
|
||||
newDbParty.fadingColor = request.fadingColor();
|
||||
newDbParty.name = QString::fromStdString(request.name());
|
||||
newDbParty.roleId = request.role();
|
||||
newDbParty.isUsedBy = request.isUsedBy();
|
||||
newDbParty.hlaForceIdentifier = request.hlaForceIdentifier().underlying();
|
||||
newDbParty.properties = QString::fromStdString(request.properties());
|
||||
newDbParty.color = request.color;
|
||||
newDbParty.fadingColor = request.fadingColor;
|
||||
newDbParty.name = QString::fromStdString(request.name);
|
||||
newDbParty.roleId = request.role;
|
||||
newDbParty.isUsedBy = request.isUsedBy;
|
||||
newDbParty.hlaForceIdentifier = static_cast<int>(request.hlaForceIdentifier);
|
||||
newDbParty.properties = QString::fromStdString(request.properties);
|
||||
|
||||
if (!m_mainHandler->db()->insert(newDbParty))
|
||||
{
|
||||
QString errText = m_mainHandler->db()->getLastError().databaseText();
|
||||
ERROR_LOG(m_logger) << "Error inserting Party into database: " << errText;
|
||||
return Core::FunctionReplyObject(request.id(), tr_lts("dds", "Error inserting new party to database: %1")).arg(errText);
|
||||
return Core::FunctionReplyObject(request.id, tr_lts("dds", "Error inserting new party to database: %1")).arg(errText);
|
||||
}
|
||||
|
||||
partyToPublish = new Party(newDbParty);
|
||||
@@ -189,7 +189,7 @@ Core::FunctionReplyObject PartyHandling::PartyHandler::modifyPartyDataRequest(co
|
||||
else // update in database
|
||||
{
|
||||
if (!m_mainHandler->db()->update(partyToPublish->toDbParty()))
|
||||
return Core::FunctionReplyObject(request.id(), tr_lts("dds", "Error updating party in database"));
|
||||
return Core::FunctionReplyObject(request.id, tr_lts("dds", "Error updating party in database"));
|
||||
}
|
||||
}
|
||||
if (partyToPublish)
|
||||
@@ -197,7 +197,7 @@ Core::FunctionReplyObject PartyHandling::PartyHandler::modifyPartyDataRequest(co
|
||||
auto party = partyToPublish->toDdsParty();
|
||||
m_mainHandler->dts()->publish(party);
|
||||
}
|
||||
return Core::FunctionReplyObject(request.id());
|
||||
return Core::FunctionReplyObject(request.id);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------------------
|
||||
@@ -217,18 +217,18 @@ Core::FunctionReplyObject PartyHandling::PartyHandler::removePartyRequest(const
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "onRemovePartyRequest " << request;
|
||||
|
||||
if (request.partyId() < 0)
|
||||
if (request.partyId < 0)
|
||||
return Core::FunctionReplyObject(tr_lts("dds", "Got request to delete a party, but no valid party id to delete"));
|
||||
|
||||
Party *partyToDelete = m_parties.value(request.partyId());
|
||||
Party *partyToDelete = m_parties.value(request.partyId);
|
||||
if (!partyToDelete)
|
||||
return Core::FunctionReplyObject(tr_lts("dds", "Could not delete party with id %1, because no party with that id exists"))
|
||||
.arg(request.partyId());
|
||||
.arg(request.partyId);
|
||||
|
||||
if (partyToDelete->isUsedBy() == true)
|
||||
return Core::FunctionReplyObject(tr_lts("dds", "Not possible to delete a party in use"));
|
||||
|
||||
DEBUG_LOG(m_logger) << "Removing party with ID " << request.partyId();
|
||||
DEBUG_LOG(m_logger) << "Removing party with ID " << request.partyId;
|
||||
|
||||
return removeParty(partyToDelete);
|
||||
}
|
||||
@@ -299,17 +299,17 @@ void PartyHandling::PartyHandler::onSyncPartiesRequest(const rti::core::SampleId
|
||||
if (hasChanges)
|
||||
{
|
||||
ParticipantManagement::Party req;
|
||||
req.id(partyId);
|
||||
req.id = partyId;
|
||||
|
||||
// taking new properties from ex_0
|
||||
req.color(partyEx0.color);
|
||||
req.fadingColor(partyEx0.fadingColor);
|
||||
req.name(partyEx0.name.toStdString());
|
||||
req.role(partyEx0.roleId);
|
||||
req.hlaForceIdentifier(static_cast<HlaForceIdentifierEnum>(partyEx0.hlaForceIdentifier));
|
||||
req.color = partyEx0.color;
|
||||
req.fadingColor = partyEx0.fadingColor;
|
||||
req.name = partyEx0.name.toStdString();
|
||||
req.role = partyEx0.roleId;
|
||||
req.hlaForceIdentifier = static_cast<HlaForceIdentifierEnum>(partyEx0.hlaForceIdentifier);
|
||||
|
||||
// this remains as it is
|
||||
req.isUsedBy(partyEx->isUsedBy());
|
||||
req.isUsedBy = partyEx->isUsedBy();
|
||||
|
||||
auto ret = modifyPartyDataRequest(req);
|
||||
if (ret.error())
|
||||
@@ -363,22 +363,22 @@ void PartyHandling::PartyHandler::onChangePartyUsedStateRequest(const rti::core:
|
||||
//------------------------------------------------------------------------------------------
|
||||
Core::FunctionReplyObject PartyHandling::PartyHandler::changePartyUsedStateRequest(const ParticipantManagement::ChangePartyUsedStateRequest &request)
|
||||
{
|
||||
Party *party = m_parties.value(request.partyId());
|
||||
Party *party = m_parties.value(request.partyId);
|
||||
if (!party)
|
||||
return Core::FunctionReplyObject(request.partyId(), tr_lts("dds", "Could not modify party with id %1, because no party with that id exists"))
|
||||
.arg(request.partyId());
|
||||
return Core::FunctionReplyObject(request.partyId, tr_lts("dds", "Could not modify party with id %1, because no party with that id exists"))
|
||||
.arg(request.partyId);
|
||||
|
||||
ParticipantManagement::Party ddsParty = party->toDdsParty();
|
||||
ddsParty.isUsedBy(request.isUsedBy());
|
||||
ddsParty.isUsedBy = request.isUsedBy;
|
||||
if (party->hasChanges(ddsParty, false))
|
||||
{
|
||||
if (!m_mainHandler->db()->update(party->toDbParty()))
|
||||
return Core::FunctionReplyObject(request.partyId(), tr_lts("dds", "Error updating party used state in database"));
|
||||
return Core::FunctionReplyObject(request.partyId, tr_lts("dds", "Error updating party used state in database"));
|
||||
|
||||
DEBUG_LOG(m_logger) << "Change used state for party " << party->id() << " to " << party->isUsedBy();
|
||||
m_mainHandler->dts()->publish(party->toDdsParty());
|
||||
}
|
||||
return Core::FunctionReplyObject(request.partyId());
|
||||
return Core::FunctionReplyObject(request.partyId);
|
||||
}
|
||||
|
||||
|
||||
|
||||
+22
-22
@@ -27,36 +27,36 @@ ParticipantHandlerForReplay::ParticipantHandlerForReplay(RecordReplayPluginCusto
|
||||
static inline Database::PpmParticipant toDb(const ParticipantManagement::Participant &ddsPart)
|
||||
{
|
||||
Database::PpmParticipant db;
|
||||
db.id = ddsPart.id();
|
||||
db.assignState = ddsPart.assignState();
|
||||
db.partyId = ddsPart.partyId();
|
||||
db.typeId = ddsPart.typeId();
|
||||
db.externalId = ddsPart.externalId();
|
||||
db.designator = QString::fromStdString(ddsPart.designator());
|
||||
db.equipmentNumber = ddsPart.equipmentNumber.is_set() ? ddsPart.equipmentNumber.get() : 0;
|
||||
db.hierarchyNumber = ddsPart.hierarchyNumber();
|
||||
db.identification = QString::fromStdString(ddsPart.identification());
|
||||
db.info = QString::fromStdString(ddsPart.info());
|
||||
db.isDeleted = ddsPart.isDeleted();
|
||||
db.isSimulated = ddsPart.isSimulated();
|
||||
db.name = QString::fromStdString(ddsPart.name());
|
||||
db.superiorId = ddsPart.superiorId();
|
||||
db.symbol = QString::fromStdString(ddsPart.symbol());
|
||||
db.tacticalIdentifier = QString::fromStdString(ddsPart.tacticalIdentifier());
|
||||
db.properties = QString::fromStdString(ddsPart.properties());
|
||||
db.id = ddsPart.id;
|
||||
db.assignState = ddsPart.assignState;
|
||||
db.partyId = ddsPart.partyId;
|
||||
db.typeId = ddsPart.typeId;
|
||||
db.externalId = ddsPart.externalId;
|
||||
db.designator = QString::fromStdString(ddsPart.designator);
|
||||
db.equipmentNumber = ddsPart.equipmentNumber.has_value() ? ddsPart.equipmentNumber.get() : 0;
|
||||
db.hierarchyNumber = ddsPart.hierarchyNumber;
|
||||
db.identification = QString::fromStdString(ddsPart.identification);
|
||||
db.info = QString::fromStdString(ddsPart.info);
|
||||
db.isDeleted = ddsPart.isDeleted;
|
||||
db.isSimulated = ddsPart.isSimulated;
|
||||
db.name = QString::fromStdString(ddsPart.name);
|
||||
db.superiorId = ddsPart.superiorId;
|
||||
db.symbol = QString::fromStdString(ddsPart.symbol);
|
||||
db.tacticalIdentifier = QString::fromStdString(ddsPart.tacticalIdentifier);
|
||||
db.properties = QString::fromStdString(ddsPart.properties);
|
||||
|
||||
return db;
|
||||
}
|
||||
|
||||
void ParticipantHandlerForReplay::createUpdateParticipant(const ParticipantManagement::Participant &ddsPart)
|
||||
{
|
||||
auto *p = m_participants.value(ddsPart.id());
|
||||
auto *p = m_participants.value(ddsPart.id);
|
||||
if (!p)
|
||||
{
|
||||
p = new ParticipantForReplay(this,
|
||||
m_unitPositionCalculator.get(),
|
||||
toDb(ddsPart));
|
||||
m_participants.insert(ddsPart.id(), p);
|
||||
m_participants.insert(ddsPart.id, p);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -68,7 +68,7 @@ void ParticipantHandlerForReplay::removeParticipant(const ParticipantManagement:
|
||||
{
|
||||
// maybe clear m_hitLineInfoMap for this participant also but is this a real-world problem?
|
||||
|
||||
auto *p = m_participants.take(ddsPart.id());
|
||||
auto *p = m_participants.take(ddsPart.id);
|
||||
if (p)
|
||||
{
|
||||
p->removeFromDds();
|
||||
@@ -79,9 +79,9 @@ void ParticipantHandlerForReplay::removeParticipant(const ParticipantManagement:
|
||||
|
||||
void ParticipantHandlerForReplay::setDynamicParticipantData(const ParticipantManagement::DynamicParticipantData &dynPart)
|
||||
{
|
||||
auto *p = m_participants.value(dynPart.participantId());
|
||||
auto *p = m_participants.value(dynPart.participantId);
|
||||
if (!p) {
|
||||
WARNING_LOG(m_logger) << "Got dynamic participant data for unknown participant with id " << dynPart.participantId();
|
||||
WARNING_LOG(m_logger) << "Got dynamic participant data for unknown participant with id " << dynPart.participantId;
|
||||
return;
|
||||
}
|
||||
p->setDynamicData(dynPart);
|
||||
|
||||
+4
-4
@@ -88,7 +88,7 @@ void RecordReplayPluginCustom::removeOld(QMultiMap<long long, T> &map, qint64 de
|
||||
for (const auto &inner : map.values(item))
|
||||
{
|
||||
// Remove delted ones
|
||||
if (inner.isDeleted())
|
||||
if (inner.isDeleted)
|
||||
{
|
||||
map.remove(item, inner);
|
||||
}
|
||||
@@ -125,7 +125,7 @@ bool RecordReplayPluginCustom::setReplayStartTime(NSqlQuery &q, qint64 startTime
|
||||
// {
|
||||
// for (const auto &p : m_participantMap)
|
||||
// {
|
||||
// if (p.equipmentNumber.is_set())
|
||||
// if (p.equipmentNumber.has_value())
|
||||
// m_equipmentNumbers.insert(p.equipmentNumber.get());
|
||||
// }
|
||||
// DEBUG_LOG(m_logger) << "setReplayStartTime-m_equipmentNumbers after" << m_equipmentNumbers.count();
|
||||
@@ -144,7 +144,7 @@ bool RecordReplayPluginCustom::setReplayStartTime(NSqlQuery &q, qint64 startTime
|
||||
const auto &inner = backup.values(key);
|
||||
for (const auto &value : inner)
|
||||
{
|
||||
if (m_participantKeys.find(value.participantId()) == m_participantKeys.end())
|
||||
if (m_participantKeys.find(value.participantId) == m_participantKeys.end())
|
||||
m_dynamicParticipantDataMap.remove(key, value);
|
||||
}
|
||||
}
|
||||
@@ -334,7 +334,7 @@ QVector<QFuture<void>> RecordReplayPluginCustom::makeConcurrent(T &content, qint
|
||||
for (auto it = contentIndex.begin(); it != contentIndex.end(); ++it)
|
||||
{
|
||||
// following is relavant to a) OPTIMZE = true; // GUEZE-3521 and b) E01562-183 "Prüfung Replay"
|
||||
if (m_equipmentNumbers.isEmpty() || m_equipmentNumbers.contains(abs(it->equipmentNumber())))
|
||||
if (m_equipmentNumbers.isEmpty() || m_equipmentNumbers.contains(abs(it->equipmentNumber)))
|
||||
m_participantHandler->newData(*it);
|
||||
}
|
||||
}));
|
||||
|
||||
+6
-6
@@ -80,7 +80,7 @@ void HandlerTargetInformation::onModifyTargetInformationRequest(const rti::core:
|
||||
Core::FunctionReplyObject HandlerTargetInformation::targetInformationModifyRequest(const ModifyTargetInformationRequest &request)
|
||||
{
|
||||
TRACE_LOG(m_logger) << LOGFUNCTION << " START";
|
||||
const int requestId = request.targetInfo().id();
|
||||
const int requestId = request.targetInfo.id;
|
||||
// modify
|
||||
if (requestId > 0)
|
||||
{
|
||||
@@ -88,12 +88,12 @@ Core::FunctionReplyObject HandlerTargetInformation::targetInformationModifyReque
|
||||
if (!ifs)
|
||||
return Core::FunctionReplyObject(requestId, tr_lts("dds", "TargetInformation with id %1 not found")).arg(requestId);
|
||||
|
||||
auto ret = ifs->updateObject(request.targetInfo());
|
||||
auto ret = ifs->updateObject(request.targetInfo);
|
||||
return ret;
|
||||
}
|
||||
// create
|
||||
ObjectTargetInformation *ifs(new ObjectTargetInformation(m_mainHandler));
|
||||
auto ret = ifs->createObject(request.targetInfo());
|
||||
auto ret = ifs->createObject(request.targetInfo);
|
||||
if (ret.error())
|
||||
{
|
||||
delete ifs;
|
||||
@@ -112,11 +112,11 @@ void HandlerTargetInformation::onRemoveTargetInformationRequest(const rti::core:
|
||||
TRACE_LOG(m_logger) << LOGFUNCTION << " request=" << request;
|
||||
|
||||
Core::FunctionReplyObject ret;
|
||||
ObjectTargetInformation *ifs = m_objectMap.value(request.id());
|
||||
ObjectTargetInformation *ifs = m_objectMap.value(request.id);
|
||||
|
||||
if (ifs == nullptr)
|
||||
{
|
||||
ret = Core::FunctionReplyObject(request.id(), tr_lts("dds", "ShootbackTarget with id %1 not found")).arg(request.id());
|
||||
ret = Core::FunctionReplyObject(request.id, tr_lts("dds", "ShootbackTarget with id %1 not found")).arg(request.id);
|
||||
m_mainHandler->fts()->removeTargetInformationReply(cookie, ret);
|
||||
return;
|
||||
}
|
||||
@@ -128,7 +128,7 @@ void HandlerTargetInformation::onRemoveTargetInformationRequest(const rti::core:
|
||||
{
|
||||
// delete Object
|
||||
delete ifs;
|
||||
m_objectMap.remove(request.id());
|
||||
m_objectMap.remove(request.id);
|
||||
}
|
||||
|
||||
m_mainHandler->fts()->removeTargetInformationReply(cookie, ret);
|
||||
|
||||
+46
-46
@@ -25,19 +25,19 @@ Core::GeoPosition2D posFromJson(const QJsonValue &val)
|
||||
Core::GeoPosition2D element;
|
||||
{
|
||||
const QJsonValue valLon(objElement.value(QStringLiteral("lon")));
|
||||
element.lon(valLon.toDouble());
|
||||
element.lon = valLon.toDouble();
|
||||
}
|
||||
{
|
||||
const QJsonValue valLat(objElement.value(QStringLiteral("lat")));
|
||||
element.lat(valLat.toDouble());
|
||||
element.lat = valLat.toDouble();
|
||||
}
|
||||
return element;
|
||||
}
|
||||
QJsonObject toJson(const Core::GeoPosition2D &element)
|
||||
{
|
||||
QJsonObject obj;
|
||||
obj[QStringLiteral("lon")] = element.lon();
|
||||
obj[QStringLiteral("lat")] = element.lat();
|
||||
obj[QStringLiteral("lon")] = element.lon;
|
||||
obj[QStringLiteral("lat")] = element.lat;
|
||||
return obj;
|
||||
}
|
||||
|
||||
@@ -47,15 +47,15 @@ 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());
|
||||
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)) );
|
||||
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;
|
||||
}
|
||||
@@ -63,13 +63,13 @@ ShootbackArea areaFromJson(const QJsonValue &val)
|
||||
QJsonObject toJson(const ShootbackArea &area)
|
||||
{
|
||||
QJsonObject obj;
|
||||
obj.insert(QStringLiteral("identifier"), QString::fromStdString(area.identifier()));
|
||||
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()));
|
||||
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;
|
||||
}
|
||||
@@ -121,14 +121,14 @@ ObjectTargetInformation::~ObjectTargetInformation()
|
||||
{
|
||||
TRACE_LOG(m_logger) << LOGFUNCTION << " START";
|
||||
if (isValid())
|
||||
m_mainHandler->dts()->removeTargetInformationByKey(m_data.id());
|
||||
m_mainHandler->dts()->removeTargetInformationByKey(m_data.id);
|
||||
TRACE_LOG(m_logger) << LOGFUNCTION << " END";
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
bool ObjectTargetInformation::isValid() const
|
||||
{
|
||||
return m_data.id() > 0;
|
||||
return m_data.id > 0;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
@@ -137,14 +137,14 @@ Core::FunctionReplyObject ObjectTargetInformation::createObject(const TargetInfo
|
||||
TRACE_LOG(m_logger) << LOGFUNCTION << " START";
|
||||
m_data = data;
|
||||
|
||||
if (m_data.id() <= 0)
|
||||
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);
|
||||
m_data.id = dbData.id;
|
||||
DEBUG_LOG(m_logger) << "New PpmTargetInformation: " /*<< m_data.id()*/;
|
||||
}
|
||||
|
||||
@@ -152,29 +152,29 @@ Core::FunctionReplyObject ObjectTargetInformation::createObject(const TargetInfo
|
||||
onPublishData();
|
||||
|
||||
TRACE_LOG(m_logger) << LOGFUNCTION << " END";
|
||||
return Core::FunctionReplyObject(m_data.id());
|
||||
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();
|
||||
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"));
|
||||
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();
|
||||
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());
|
||||
TRACE_LOG(m_logger) << LOGFUNCTION << " END, id=" << data.id
|
||||
<< " size =" << data.shootbackAreas.size();
|
||||
return Core::FunctionReplyObject(m_data.id);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
@@ -182,21 +182,21 @@ 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->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());
|
||||
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());
|
||||
return Core::FunctionReplyObject(m_data.id);
|
||||
}
|
||||
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
void ObjectTargetInformation::onPublishData()
|
||||
{
|
||||
TRACE_LOG(m_logger) << "Publish TargetInformation-data to dds (" << m_data.id() << ") ...";
|
||||
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";
|
||||
@@ -211,15 +211,15 @@ Database::PpmTargetInformation ObjectTargetInformation::toDbData(const TargetInf
|
||||
{
|
||||
Database::PpmTargetInformation dbData;
|
||||
|
||||
dbData.id = ddsData.id();
|
||||
dbData.participantId = ddsData.participantId();
|
||||
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());
|
||||
dbData.preWarningInterval = ddsData.prewarningInterval;
|
||||
dbData.preWarningEffect = static_cast<int>(ddsData.prewarningEffect);
|
||||
dbData.takeDownInterval = ddsData.takedownInterval;
|
||||
dbData.takeDownEffect = static_cast<int>(ddsData.takedownEffect);
|
||||
|
||||
const std::vector<ParticipantManagement::ShootbackArea>& shootback_areas = ddsData.shootbackAreas();
|
||||
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() );
|
||||
@@ -233,13 +233,13 @@ TargetInformation ObjectTargetInformation::toDdsData(const Database::PpmTargetIn
|
||||
{
|
||||
TargetInformation ddsData;
|
||||
|
||||
ddsData.id(dbData.id);
|
||||
ddsData.participantId(dbData.participantId);
|
||||
ddsData.id = dbData.id;
|
||||
ddsData.participantId = dbData.participantId;
|
||||
|
||||
ddsData.prewarningInterval(dbData.preWarningInterval);
|
||||
ddsData.prewarningEffect(static_cast<ProjectDataManagement::VulnerabilityState>(dbData.preWarningEffect));
|
||||
ddsData.takedownInterval(dbData.takeDownInterval);
|
||||
ddsData.takedownEffect(static_cast<ProjectDataManagement::VulnerabilityState>(dbData.takeDownEffect));
|
||||
ddsData.prewarningInterval = dbData.preWarningInterval;
|
||||
ddsData.prewarningEffect = static_cast<ProjectDataManagement::VulnerabilityState>(dbData.preWarningEffect);
|
||||
ddsData.takedownInterval = dbData.takeDownInterval;
|
||||
ddsData.takedownEffect = static_cast<ProjectDataManagement::VulnerabilityState>(dbData.takeDownEffect);
|
||||
|
||||
const QByteArray &propertiesBa = dbData.properties.toUtf8();
|
||||
QJsonParseError parserError;
|
||||
@@ -252,7 +252,7 @@ TargetInformation ObjectTargetInformation::toDdsData(const Database::PpmTargetIn
|
||||
|
||||
QJsonObject obj(doc.object());
|
||||
const std::vector<ShootbackArea> &sbAreas = vecfromJson(obj);
|
||||
ddsData.shootbackAreas(sbAreas);
|
||||
ddsData.shootbackAreas = sbAreas;
|
||||
|
||||
return ddsData;
|
||||
}
|
||||
|
||||
+2
-2
@@ -35,8 +35,8 @@ public:
|
||||
Core::FunctionReplyObject updateObject(const TargetInformation &data);
|
||||
Core::FunctionReplyObject removeObject();
|
||||
|
||||
qint32 getId() const { return m_data.id(); }
|
||||
qint32 getParticipantId() const { return m_data.participantId(); }
|
||||
qint32 getId() const { return m_data.id; }
|
||||
qint32 getParticipantId() const { return m_data.participantId; }
|
||||
const TargetInformation &getData() const { return m_data; }
|
||||
|
||||
bool isValid() const;
|
||||
|
||||
+27
-27
@@ -11,18 +11,18 @@ ParticipantManagement::TemplateParticipant ParticipantManagement::TemplateHandli
|
||||
{
|
||||
TemplateParticipant result;
|
||||
|
||||
result.templateId(id());
|
||||
result.typeId(typeId());
|
||||
result.name(m_data.name.toStdString());
|
||||
result.designator(m_data.designator.toStdString());
|
||||
result.info(m_data.info.toStdString());
|
||||
result.symbol(m_data.symbol.toStdString());
|
||||
result.tacticalIdentifier(m_data.tacticalIdentifier.toStdString());
|
||||
result.hierarchyNumber(m_data.hierarchyNumber);
|
||||
result.superiorTemplateId(superiorId());
|
||||
result.equipmentNumber(m_data.equipmentNumber);
|
||||
result.templateId = id();
|
||||
result.typeId = typeId();
|
||||
result.name = m_data.name.toStdString();
|
||||
result.designator = m_data.designator.toStdString();
|
||||
result.info = m_data.info.toStdString();
|
||||
result.symbol = m_data.symbol.toStdString();
|
||||
result.tacticalIdentifier = m_data.tacticalIdentifier.toStdString();
|
||||
result.hierarchyNumber = m_data.hierarchyNumber;
|
||||
result.superiorTemplateId = superiorId();
|
||||
result.equipmentNumber = m_data.equipmentNumber;
|
||||
if (!m_inferiorIds.empty())
|
||||
result.inferiorIds().set(m_inferiorIds);
|
||||
result.inferiorIds.set(m_inferiorIds);
|
||||
|
||||
return result;
|
||||
}
|
||||
@@ -30,25 +30,25 @@ ParticipantManagement::TemplateParticipant ParticipantManagement::TemplateHandli
|
||||
bool ParticipantManagement::TemplateHandling::Template::hasToBeChanged(const ParticipantManagement::TemplateData &newData)
|
||||
{
|
||||
bool hasNoChanges =
|
||||
m_data.typeId == newData.typeId() &&
|
||||
m_data.hierarchyNumber == newData.hierarchyNumber() &&
|
||||
m_data.equipmentNumber == newData.equipmentNumber() &&
|
||||
m_data.name == QString::fromStdString(newData.name()) &&
|
||||
m_data.symbol == QString::fromStdString(newData.symbol()) &&
|
||||
m_data.info == QString::fromStdString(newData.info()) &&
|
||||
m_data.designator == QString::fromStdString(newData.designator()) &&
|
||||
m_data.tacticalIdentifier == QString::fromStdString(newData.tacticalIdentifier());
|
||||
m_data.typeId == newData.typeId &&
|
||||
m_data.hierarchyNumber == newData.hierarchyNumber &&
|
||||
m_data.equipmentNumber == newData.equipmentNumber &&
|
||||
m_data.name == QString::fromStdString(newData.name) &&
|
||||
m_data.symbol == QString::fromStdString(newData.symbol) &&
|
||||
m_data.info == QString::fromStdString(newData.info) &&
|
||||
m_data.designator == QString::fromStdString(newData.designator) &&
|
||||
m_data.tacticalIdentifier == QString::fromStdString(newData.tacticalIdentifier);
|
||||
|
||||
if (!hasNoChanges)
|
||||
{
|
||||
m_data.typeId = newData.typeId();
|
||||
m_data.hierarchyNumber = newData.hierarchyNumber();
|
||||
m_data.name = QString::fromStdString(newData.name());
|
||||
m_data.symbol = QString::fromStdString(newData.symbol());
|
||||
m_data.info = QString::fromStdString(newData.info());
|
||||
m_data.designator = QString::fromStdString(newData.designator());
|
||||
m_data.tacticalIdentifier = QString::fromStdString(newData.tacticalIdentifier());
|
||||
m_data.equipmentNumber = newData.equipmentNumber();
|
||||
m_data.typeId = newData.typeId;
|
||||
m_data.hierarchyNumber = newData.hierarchyNumber;
|
||||
m_data.name = QString::fromStdString(newData.name);
|
||||
m_data.symbol = QString::fromStdString(newData.symbol);
|
||||
m_data.info = QString::fromStdString(newData.info);
|
||||
m_data.designator = QString::fromStdString(newData.designator);
|
||||
m_data.tacticalIdentifier = QString::fromStdString(newData.tacticalIdentifier);
|
||||
m_data.equipmentNumber = newData.equipmentNumber;
|
||||
}
|
||||
|
||||
return !hasNoChanges;
|
||||
|
||||
+40
-42
@@ -72,19 +72,19 @@ Core::FunctionReplyObject TemplateHandler::modifyTemplateDataRequest(const Parti
|
||||
QHash<int32_t, int32_t> modIdToTemplateId; // <modId, templateId>
|
||||
QVector<ParticipantManagement::TemplateData> templatesToBeCreatedOrModified;
|
||||
|
||||
templatesToBeCreatedOrModified.reserve(request.data().size());
|
||||
templatesToBeCreatedOrModified.reserve(request.data.size());
|
||||
|
||||
DBTransaction removeTransaction(m_mainHandler->db()->database());
|
||||
// first remove templates which are marked to be removed
|
||||
for (const TemplateData ¤tTemplate : request.data())
|
||||
for (const TemplateData ¤tTemplate : request.data)
|
||||
{
|
||||
if (currentTemplate.isDeleted())
|
||||
if (currentTemplate.isDeleted)
|
||||
{
|
||||
if (currentTemplate.templateId() <= 0)
|
||||
if (currentTemplate.templateId <= 0)
|
||||
return Core::FunctionReplyObject(tr_lts("dds",
|
||||
"Internal error - Not possible to remove templateData with modId %1, because it does not have templateId set"))
|
||||
.arg(currentTemplate.modId());
|
||||
const auto ret = deleteTemplateById(currentTemplate.templateId(), true);
|
||||
.arg(currentTemplate.modId);
|
||||
const auto ret = deleteTemplateById(currentTemplate.templateId, true);
|
||||
if (ret.error())
|
||||
return ret;
|
||||
}
|
||||
@@ -106,12 +106,10 @@ Core::FunctionReplyObject TemplateHandler::modifyTemplateDataRequest(const Parti
|
||||
futureVec.reserve(vecSize);
|
||||
for (int startIndex = 0; startIndex < templatesToBeCreatedOrModified.size(); startIndex += range)
|
||||
{
|
||||
QFuture<Core::FunctionReplyObject> fut = QtConcurrent::run(this,
|
||||
&TemplateHandler::validateTemplateData,
|
||||
templatesToBeCreatedOrModified,
|
||||
modIdToTemplateId,
|
||||
startIndex,
|
||||
range);
|
||||
QFuture<Core::FunctionReplyObject> fut = QtConcurrent::run(
|
||||
[this, templatesToBeCreatedOrModified, modIdToTemplateId, startIndex, range]() mutable -> Core::FunctionReplyObject {
|
||||
return validateTemplateData(templatesToBeCreatedOrModified, modIdToTemplateId, startIndex, range);
|
||||
});
|
||||
futureVec += fut;
|
||||
}
|
||||
|
||||
@@ -142,7 +140,7 @@ Core::FunctionReplyObject TemplateHandler::modifyTemplateDataRequest(const Parti
|
||||
|
||||
for (const TemplateData ¤tData : std::as_const(templatesToBeCreatedOrModified))
|
||||
{
|
||||
Template *templateToUpdate = m_templates.value(modIdToTemplateId.value(currentData.modId()));
|
||||
Template *templateToUpdate = m_templates.value(modIdToTemplateId.value(currentData.modId));
|
||||
if (!templateToUpdate)
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "Creating new template: " << currentData;
|
||||
@@ -167,8 +165,8 @@ Core::FunctionReplyObject TemplateHandler::modifyTemplateDataRequest(const Parti
|
||||
// build hierarchy
|
||||
for (const TemplateData ¤tData : std::as_const(templatesToBeCreatedOrModified)) // first set superiorIds
|
||||
{
|
||||
Template *templateToUpdate = m_templates.value(modIdToTemplateId.value(currentData.modId()), nullptr);
|
||||
const int superiorId = modIdToTemplateId.value(currentData.superiorModId());
|
||||
Template *templateToUpdate = m_templates.value(modIdToTemplateId.value(currentData.modId), nullptr);
|
||||
const int superiorId = modIdToTemplateId.value(currentData.superiorModId);
|
||||
if (!templateToUpdate->hasNewSuperiorId(superiorId) ||
|
||||
templatesWithChanges.contains(templateToUpdate))
|
||||
continue;
|
||||
@@ -223,15 +221,15 @@ Core::FunctionReplyObject TemplateHandler::createNewTemplate(const ParticipantMa
|
||||
// create new template
|
||||
Database::PpmTemplate newDbTemplate;
|
||||
|
||||
newDbTemplate.typeId = currentData.typeId();
|
||||
newDbTemplate.name = QString::fromStdString(currentData.name());
|
||||
newDbTemplate.symbol = QString::fromStdString(currentData.symbol());
|
||||
newDbTemplate.info = QString::fromStdString(currentData.info());
|
||||
newDbTemplate.designator = QString::fromStdString(currentData.designator());
|
||||
newDbTemplate.tacticalIdentifier = QString::fromStdString(currentData.tacticalIdentifier());
|
||||
newDbTemplate.superiorId = modIdToTemplateId.value(currentData.superiorModId(), 0);
|
||||
newDbTemplate.hierarchyNumber = currentData.hierarchyNumber();
|
||||
newDbTemplate.equipmentNumber = currentData.equipmentNumber();
|
||||
newDbTemplate.typeId = currentData.typeId;
|
||||
newDbTemplate.name = QString::fromStdString(currentData.name);
|
||||
newDbTemplate.symbol = QString::fromStdString(currentData.symbol);
|
||||
newDbTemplate.info = QString::fromStdString(currentData.info);
|
||||
newDbTemplate.designator = QString::fromStdString(currentData.designator);
|
||||
newDbTemplate.tacticalIdentifier = QString::fromStdString(currentData.tacticalIdentifier);
|
||||
newDbTemplate.superiorId = modIdToTemplateId.value(currentData.superiorModId, 0);
|
||||
newDbTemplate.hierarchyNumber = currentData.hierarchyNumber;
|
||||
newDbTemplate.equipmentNumber = currentData.equipmentNumber;
|
||||
|
||||
// creating db entry
|
||||
if (!m_mainHandler->db()->insert(newDbTemplate))
|
||||
@@ -242,7 +240,7 @@ Core::FunctionReplyObject TemplateHandler::createNewTemplate(const ParticipantMa
|
||||
Template *newTemplate = new Template(newDbTemplate);
|
||||
|
||||
m_templates.insert(newTemplate->id(), newTemplate);
|
||||
modIdToTemplateId.insert(currentData.modId(), newTemplate->id());
|
||||
modIdToTemplateId.insert(currentData.modId, newTemplate->id());
|
||||
if (!templatesWithChanges.contains(newTemplate))
|
||||
templatesWithChanges.append(newTemplate);
|
||||
|
||||
@@ -253,32 +251,32 @@ Core::FunctionReplyObject TemplateHandler::validateTemplateData(const QVector<Te
|
||||
QHash<int32_t, int32_t> &modIdToTemplateId,
|
||||
const ParticipantManagement::TemplateData &templateToValidate)
|
||||
{
|
||||
if (templateToValidate.templateId() != 0)
|
||||
if (templateToValidate.templateId != 0)
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "Checking template id";
|
||||
Template *existingTemplate = m_templates.value(templateToValidate.templateId(), nullptr);
|
||||
Template *existingTemplate = m_templates.value(templateToValidate.templateId, nullptr);
|
||||
if (existingTemplate == nullptr)
|
||||
return Core::FunctionReplyObject(tr_lts("dds",
|
||||
"Could not execute ModifyTemplateDataRequest, because an invalid template ID (%1) was given"))
|
||||
.arg(templateToValidate.templateId());
|
||||
.arg(templateToValidate.templateId);
|
||||
|
||||
DEBUG_LOG(m_logger) << "... ok";
|
||||
{
|
||||
QMutexLocker l(&m_mutex);
|
||||
modIdToTemplateId.insert(templateToValidate.modId(), existingTemplate->id()); /* register template to indicate that this template
|
||||
modIdToTemplateId.insert(templateToValidate.modId, existingTemplate->id()); /* register template to indicate that this template
|
||||
should just be modified and not newly created */
|
||||
}
|
||||
}
|
||||
|
||||
// superior ids valid?
|
||||
if (templateToValidate.superiorModId() > 0)
|
||||
if (templateToValidate.superiorModId > 0)
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "checking superiorIds";
|
||||
// superior exists?
|
||||
bool isExistingSuperiorId = false;
|
||||
for (const TemplateData &dat : dataVec)
|
||||
{
|
||||
if (templateToValidate.superiorModId() == dat.modId())
|
||||
if (templateToValidate.superiorModId == dat.modId)
|
||||
{
|
||||
isExistingSuperiorId = true;
|
||||
break; // for (const TemplateData &dat : dataVec)
|
||||
@@ -287,12 +285,12 @@ Core::FunctionReplyObject TemplateHandler::validateTemplateData(const QVector<Te
|
||||
if (!isExistingSuperiorId)
|
||||
return Core::FunctionReplyObject(tr_lts("dds",
|
||||
"Could not execute ModifyTemplateDataRequest, the data set with modId %1 has an invalid superiorModId %2"))
|
||||
.arg(templateToValidate.modId())
|
||||
.arg(templateToValidate.superiorModId());
|
||||
.arg(templateToValidate.modId)
|
||||
.arg(templateToValidate.superiorModId);
|
||||
|
||||
DEBUG_LOG(m_logger) << "... ok";
|
||||
|
||||
if (templateToValidate.hierarchyNumber() <= 0)
|
||||
if (templateToValidate.hierarchyNumber <= 0)
|
||||
return Core::FunctionReplyObject(tr_lts("dds",
|
||||
"Could not execute ModifyTemplateDataRequest, because a data set has a superior but no hierarchyNumber set"));
|
||||
|
||||
@@ -301,24 +299,24 @@ Core::FunctionReplyObject TemplateHandler::validateTemplateData(const QVector<Te
|
||||
for (const TemplateData &dat : dataVec)
|
||||
{
|
||||
// operator==() on optionals returns false if not set ...
|
||||
if (dat.modId() != templateToValidate.modId() &&
|
||||
dat.superiorModId() == templateToValidate.superiorModId() &&
|
||||
dat.hierarchyNumber() == templateToValidate.hierarchyNumber())
|
||||
if (dat.modId != templateToValidate.modId &&
|
||||
dat.superiorModId == templateToValidate.superiorModId &&
|
||||
dat.hierarchyNumber == templateToValidate.hierarchyNumber)
|
||||
return Core::FunctionReplyObject(tr_lts("dds",
|
||||
"Could not execute ModifyTemplateDataRequest, because for superiorModId %1 hierarchyNumber %2 is not unique"))
|
||||
.arg(dat.superiorModId())
|
||||
.arg(dat.hierarchyNumber());
|
||||
.arg(dat.superiorModId)
|
||||
.arg(dat.hierarchyNumber);
|
||||
}
|
||||
DEBUG_LOG(m_logger) << "... ok";
|
||||
}
|
||||
|
||||
// typeId valid?
|
||||
DEBUG_LOG(m_logger) << "Checking typeId";
|
||||
if (m_mainHandler->typeHandler()->typeById(templateToValidate.typeId()) == nullptr)
|
||||
if (m_mainHandler->typeHandler()->typeById(templateToValidate.typeId) == nullptr)
|
||||
return Core::FunctionReplyObject(tr_lts("dds",
|
||||
"Could not execute ModifyTemplateDataRequest, because data set with modId %1 has invalid typeId %2"))
|
||||
.arg(templateToValidate.modId())
|
||||
.arg(templateToValidate.typeId());
|
||||
.arg(templateToValidate.modId)
|
||||
.arg(templateToValidate.typeId);
|
||||
|
||||
DEBUG_LOG(m_logger) << "... ok";
|
||||
|
||||
|
||||
+5
-5
@@ -42,7 +42,7 @@ bool TypeHandler::isSupportType(int typeId) const
|
||||
if (!type)
|
||||
return false;
|
||||
|
||||
switch (type->typeClass().underlying())
|
||||
switch (type->typeClass)
|
||||
{
|
||||
case TypeClass::SupportEntity:
|
||||
case TypeClass::SupportUnit:
|
||||
@@ -66,7 +66,7 @@ bool TypeHandler::isParticipantType(int typeId) const
|
||||
if (!type)
|
||||
return false;
|
||||
|
||||
switch (type->typeClass().underlying())
|
||||
switch (type->typeClass)
|
||||
{
|
||||
case TypeClass::SupportEntity:
|
||||
case TypeClass::SupportUnit:
|
||||
@@ -90,7 +90,7 @@ bool TypeHandler::isUnitType(int typeId) const
|
||||
if (!type)
|
||||
return false;
|
||||
|
||||
switch (type->typeClass().underlying())
|
||||
switch (type->typeClass)
|
||||
{
|
||||
case TypeClass::Unit:
|
||||
case TypeClass::SupportUnit:
|
||||
@@ -120,7 +120,7 @@ bool TypeHandler::isArtilleryParticipantType(int typeId) const
|
||||
const ParticipantManagement::EquipmentType *TypeHandler::equipmentTypeByTypeId(int32_t typeId)
|
||||
{
|
||||
const Type *type = typeById(typeId);
|
||||
return type ? m_equipmentTypes.value(type->equipmentTypeId()) : nullptr;
|
||||
return type ? m_equipmentTypes.value(type->equipmentTypeId) : nullptr;
|
||||
}
|
||||
|
||||
std::shared_ptr<TypeHandler> TypeHandler::createInstance(MainHandler *mainHandler, NGL::INGLLogger &logger)
|
||||
@@ -143,7 +143,7 @@ bool TypeHandler::isArtilleryType(int typeId) const
|
||||
if (!type)
|
||||
return false;
|
||||
|
||||
QJsonDocument typeProperties = QJsonDocument::fromJson(QByteArray::fromStdString(type->properties()));
|
||||
QJsonDocument typeProperties = QJsonDocument::fromJson(QByteArray::fromStdString(type->properties));
|
||||
QJsonObject typePropertiesObject = typeProperties.object();
|
||||
|
||||
return typePropertiesObject.value(QStringLiteral("isArtillery")).toBool();
|
||||
|
||||
+4
-4
@@ -60,7 +60,7 @@ bool TypeHandling::TypeHandlerExercise::init()
|
||||
|
||||
void TypeHandling::TypeHandlerExercise::onTypeChanged(const ParticipantManagement::Type &data)
|
||||
{
|
||||
Type *changedType = m_types.value(data.id());
|
||||
Type *changedType = m_types.value(data.id);
|
||||
if (changedType)
|
||||
{
|
||||
*changedType = data;
|
||||
@@ -68,13 +68,13 @@ void TypeHandling::TypeHandlerExercise::onTypeChanged(const ParticipantManagemen
|
||||
else
|
||||
{
|
||||
changedType = new Type(data);
|
||||
m_types.insert(changedType->id(), changedType);
|
||||
m_types.insert(changedType->id, changedType);
|
||||
}
|
||||
}
|
||||
|
||||
void TypeHandling::TypeHandlerExercise::onEquipmentTypeChanged(const ParticipantManagement::EquipmentType &data)
|
||||
{
|
||||
EquipmentType *changedEquipmentType = m_equipmentTypes.value(data.id());
|
||||
EquipmentType *changedEquipmentType = m_equipmentTypes.value(data.id);
|
||||
if (changedEquipmentType)
|
||||
{
|
||||
*changedEquipmentType = data;
|
||||
@@ -82,7 +82,7 @@ void TypeHandling::TypeHandlerExercise::onEquipmentTypeChanged(const Participant
|
||||
else
|
||||
{
|
||||
changedEquipmentType = new EquipmentType(data);
|
||||
m_equipmentTypes.insert(changedEquipmentType->id(), changedEquipmentType);
|
||||
m_equipmentTypes.insert(changedEquipmentType->id, changedEquipmentType);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+60
-60
@@ -20,14 +20,14 @@ namespace ParticipantManagement
|
||||
static Database::PpmEquipmentType toDb(const EquipmentType &et)
|
||||
{
|
||||
Database::PpmEquipmentType db;
|
||||
db.id = et.id();
|
||||
db.name = QString::fromStdString(et.name());
|
||||
db.minEquipNo = et.minEquipNo();
|
||||
db.maxEquipNo = et.maxEquipNo();
|
||||
db.traVulnerabilityModelId = et.traVulnerabilityModelId();
|
||||
db.traPlayerTypeId = et.traPlayerTypeId();
|
||||
db.wmsTypeClassId = et.wmsTypeClass();
|
||||
db.deletedInWms = et.deletedInWms();
|
||||
db.id = et.id;
|
||||
db.name = QString::fromStdString(et.name);
|
||||
db.minEquipNo = et.minEquipNo;
|
||||
db.maxEquipNo = et.maxEquipNo;
|
||||
db.traVulnerabilityModelId = et.traVulnerabilityModelId;
|
||||
db.traPlayerTypeId = et.traPlayerTypeId;
|
||||
db.wmsTypeClassId = et.wmsTypeClass;
|
||||
db.deletedInWms = et.deletedInWms;
|
||||
|
||||
return db;
|
||||
}
|
||||
@@ -36,21 +36,21 @@ Database::PpmType toDb(const ParticipantManagement::Type &data)
|
||||
{
|
||||
Database::PpmType ret;
|
||||
|
||||
ret.id = data.id();
|
||||
ret.typeClassId = data.typeClass();
|
||||
if (data.equipmentTypeId() != 0)
|
||||
ret.equipmentTypeId = data.equipmentTypeId(); // QVariant
|
||||
ret.name = QString::fromStdString(data.name());
|
||||
ret.symbol = QString::fromStdString(data.symbol());
|
||||
ret.radioCount = data.radioCount();
|
||||
ret.hierarchyLevel = data.hierarchyLevel();
|
||||
ret.isDeleted = data.isDeleted();
|
||||
ret.id = data.id;
|
||||
ret.typeClassId = data.typeClass;
|
||||
if (data.equipmentTypeId != 0)
|
||||
ret.equipmentTypeId = data.equipmentTypeId; // QVariant
|
||||
ret.name = QString::fromStdString(data.name);
|
||||
ret.symbol = QString::fromStdString(data.symbol);
|
||||
ret.radioCount = data.radioCount;
|
||||
ret.hierarchyLevel = data.hierarchyLevel;
|
||||
ret.isDeleted = data.isDeleted;
|
||||
#ifdef Q_OS_WIN
|
||||
ret.disEntities = LtsUtils::BigintArray(data.disEntities());
|
||||
#else
|
||||
ret.disEntities = LtsUtils::BigintArray(LtsUtils::convert<std::vector<int64_t>>(data.disEntities()));
|
||||
ret.disEntities = LtsUtils::BigintArray(data.disEntities);
|
||||
#endif
|
||||
ret.properties = QString::fromStdString(data.properties());
|
||||
ret.properties = QString::fromStdString(data.properties);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -94,7 +94,7 @@ bool TypeHandling::TypeHandlerGlobal::init()
|
||||
auto cbEt = [this] (const Database::PpmEquipmentType &dbEquipmentType)
|
||||
{
|
||||
EquipmentType *newEquipmentType = new EquipmentType(convert(dbEquipmentType));
|
||||
m_equipmentTypes.insert(newEquipmentType->id(), newEquipmentType);
|
||||
m_equipmentTypes.insert(newEquipmentType->id, newEquipmentType);
|
||||
m_mainHandler->exAnyDts()->publish(*newEquipmentType);
|
||||
};
|
||||
m_mainHandler->db()->select(cbEt);
|
||||
@@ -104,7 +104,7 @@ bool TypeHandling::TypeHandlerGlobal::init()
|
||||
auto cbT = [this] (const Database::PpmType &dbType)
|
||||
{
|
||||
Type *newType = new Type(convert(dbType));
|
||||
m_types.insert(newType->id(), newType);
|
||||
m_types.insert(newType->id, newType);
|
||||
m_mainHandler->exAnyDts()->publish(*newType);
|
||||
};
|
||||
m_mainHandler->db()->select(cbT);
|
||||
@@ -116,7 +116,7 @@ void TypeHandling::TypeHandlerGlobal::onModifyTypeRequest(const rti::core::Sampl
|
||||
const ParticipantManagement::Type &request)
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "onModifyTypeRequest" << request;
|
||||
auto ret = (request.id() > 0 ? modifyTypeRequest(request) : createTypeRequest(request));
|
||||
auto ret = (request.id > 0 ? modifyTypeRequest(request) : createTypeRequest(request));
|
||||
if (ret.error())
|
||||
WARNING_LOG(m_logger) << ret();
|
||||
m_mainHandler->exAnyFts()->modifyTypeReply(cookie, ret);
|
||||
@@ -124,17 +124,17 @@ void TypeHandling::TypeHandlerGlobal::onModifyTypeRequest(const rti::core::Sampl
|
||||
|
||||
Core::FunctionReplyObject TypeHandling::TypeHandlerGlobal::createTypeRequest(const ParticipantManagement::Type &request)
|
||||
{
|
||||
if (request.equipmentTypeId() != 0 && !m_equipmentTypes.contains(request.equipmentTypeId()))
|
||||
return Core::FunctionReplyObject(-1, tr_lts("dds", "Could not add new Type - equipmentTypeId %1 invalid")).arg(request.equipmentTypeId());
|
||||
if (request.equipmentTypeId != 0 && !m_equipmentTypes.contains(request.equipmentTypeId))
|
||||
return Core::FunctionReplyObject(-1, tr_lts("dds", "Could not add new Type - equipmentTypeId %1 invalid")).arg(request.equipmentTypeId);
|
||||
|
||||
Database::PpmType newPpmType(toDb(request));
|
||||
if (!m_mainHandler->db()->insert(newPpmType))
|
||||
return Core::FunctionReplyObject(-1, tr_lts("dds", "Could not add new Type - insert statement failed"));
|
||||
|
||||
Type *newType = new Type(request);
|
||||
newType->id(newPpmType.id);
|
||||
newType->id = newPpmType.id;
|
||||
// insert into map
|
||||
m_types.insert(newType->id(), newType);
|
||||
m_types.insert(newType->id, newType);
|
||||
|
||||
// publish to dds
|
||||
m_mainHandler->exAnyDts()->publish(*newType);
|
||||
@@ -146,15 +146,15 @@ Core::FunctionReplyObject TypeHandling::TypeHandlerGlobal::createTypeRequest(con
|
||||
|
||||
Core::FunctionReplyObject TypeHandling::TypeHandlerGlobal::modifyTypeRequest(const ParticipantManagement::Type &request)
|
||||
{
|
||||
Type *typeToBeModified = m_types.value(request.id());
|
||||
Type *typeToBeModified = m_types.value(request.id);
|
||||
if (!typeToBeModified)
|
||||
return Core::FunctionReplyObject(request.id(), tr_lts("dds", "Could not add new Type - Type with id %1 not available")).arg(request.id());
|
||||
return Core::FunctionReplyObject(request.id, tr_lts("dds", "Could not add new Type - Type with id %1 not available")).arg(request.id);
|
||||
|
||||
if (typeToBeModified->equipmentTypeId() != request.equipmentTypeId())
|
||||
return Core::FunctionReplyObject(request.id(), tr_lts("dds", "It is not allowed to modify the Equipment Type of a Type"));
|
||||
if (typeToBeModified->equipmentTypeId != request.equipmentTypeId)
|
||||
return Core::FunctionReplyObject(request.id, tr_lts("dds", "It is not allowed to modify the Equipment Type of a Type"));
|
||||
|
||||
if (!m_mainHandler->db()->update(toDb(request)))
|
||||
return Core::FunctionReplyObject(request.id(), tr_lts("dds", "Could not modify Type in database"));
|
||||
return Core::FunctionReplyObject(request.id, tr_lts("dds", "Could not modify Type in database"));
|
||||
|
||||
DEBUG_LOG(m_logger) << "Old Type data:\n"
|
||||
<< *typeToBeModified
|
||||
@@ -163,7 +163,7 @@ Core::FunctionReplyObject TypeHandling::TypeHandlerGlobal::modifyTypeRequest(con
|
||||
*typeToBeModified = request;
|
||||
m_mainHandler->exAnyDts()->publish(*typeToBeModified);
|
||||
|
||||
return Core::FunctionReplyObject(request.id());
|
||||
return Core::FunctionReplyObject(request.id);
|
||||
}
|
||||
|
||||
void TypeHandling::TypeHandlerGlobal::onRemoveTypeRequest(const rti::core::SampleIdentity &cookie,
|
||||
@@ -171,24 +171,24 @@ void TypeHandling::TypeHandlerGlobal::onRemoveTypeRequest(const rti::core::Sampl
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "onRemoveTypeRequest " << request;
|
||||
|
||||
Core::FunctionReplyObject rep(request.typeId());
|
||||
Type *typeToBeRemoved = m_types.value(request.typeId());
|
||||
Core::FunctionReplyObject rep(request.typeId);
|
||||
Type *typeToBeRemoved = m_types.value(request.typeId);
|
||||
if (typeToBeRemoved)
|
||||
{
|
||||
if (isTypeUsed(typeToBeRemoved->id()))
|
||||
rep = Core::FunctionReplyObject(request.typeId(), tr_lts("dds", "Type '%1' with type id %2 cannot be removed, type is used")).arg(typeToBeRemoved->name()).arg(request.typeId());
|
||||
if (isTypeUsed(typeToBeRemoved->id))
|
||||
rep = Core::FunctionReplyObject(request.typeId, tr_lts("dds", "Type '%1' with type id %2 cannot be removed, type is used")).arg(typeToBeRemoved->name).arg(request.typeId);
|
||||
else
|
||||
{
|
||||
typeToBeRemoved->isDeleted(true);
|
||||
typeToBeRemoved->isDeleted = true;
|
||||
|
||||
if (!m_mainHandler->db()->update(toDb(*typeToBeRemoved)))
|
||||
rep = Core::FunctionReplyObject(request.typeId(), tr_lts("dds", "Could not mark type with id %1 as deleted in database")).arg(request.typeId());
|
||||
rep = Core::FunctionReplyObject(request.typeId, tr_lts("dds", "Could not mark type with id %1 as deleted in database")).arg(request.typeId);
|
||||
|
||||
m_mainHandler->exAnyDts()->publish(*typeToBeRemoved);
|
||||
}
|
||||
}
|
||||
else
|
||||
rep = Core::FunctionReplyObject(request.typeId(), tr_lts("dds", "RemoveTypeRequest for non existing type with id %1")).arg(request.typeId());
|
||||
rep = Core::FunctionReplyObject(request.typeId, tr_lts("dds", "RemoveTypeRequest for non existing type with id %1")).arg(request.typeId);
|
||||
|
||||
if (rep.error())
|
||||
WARNING_LOG(m_logger) << rep();
|
||||
@@ -201,18 +201,18 @@ void TypeHandling::TypeHandlerGlobal::onModifyEquipmentTypeDataRequest(const rti
|
||||
{
|
||||
Core::FunctionReplyObject rep;
|
||||
|
||||
INFO_LOG(m_logger) << "Got " << request.data().size() << " equipment types to modify";
|
||||
INFO_LOG(m_logger) << "Got " << request.data.size() << " equipment types to modify";
|
||||
|
||||
QSet<int> activeIds;
|
||||
activeIds.reserve(request.data().size());
|
||||
activeIds.reserve(request.data.size());
|
||||
|
||||
for (const EquipmentType ¤tData : request.data())
|
||||
for (const EquipmentType ¤tData : request.data)
|
||||
{
|
||||
bool bPublishData = false;
|
||||
EquipmentType *existingEquipmentType = m_equipmentTypes.value(currentData.id(), nullptr);
|
||||
EquipmentType *existingEquipmentType = m_equipmentTypes.value(currentData.id, nullptr);
|
||||
if (existingEquipmentType) // update existing equipment type
|
||||
{
|
||||
activeIds += currentData.id();
|
||||
activeIds += currentData.id;
|
||||
|
||||
if (*existingEquipmentType != currentData)
|
||||
{
|
||||
@@ -220,7 +220,7 @@ void TypeHandling::TypeHandlerGlobal::onModifyEquipmentTypeDataRequest(const rti
|
||||
*existingEquipmentType = currentData;
|
||||
if (!m_mainHandler->db()->update(toDb(currentData)))
|
||||
{
|
||||
rep = Core::FunctionReplyObject(currentData.id(), tr_lts("dds", "Error updating equipment type with %1 data in database")).arg(currentData.id());
|
||||
rep = Core::FunctionReplyObject(currentData.id, tr_lts("dds", "Error updating equipment type with %1 data in database")).arg(currentData.id);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -230,54 +230,54 @@ void TypeHandling::TypeHandlerGlobal::onModifyEquipmentTypeDataRequest(const rti
|
||||
Database::PpmEquipmentType dbEquipmentType(toDb(currentData));
|
||||
if (!m_mainHandler->db()->insert(dbEquipmentType))
|
||||
{
|
||||
rep = Core::FunctionReplyObject(currentData.id(), tr_lts("dds", "Error inserting equipment type with %1 data in database")).arg(currentData.id());
|
||||
rep = Core::FunctionReplyObject(currentData.id, tr_lts("dds", "Error inserting equipment type with %1 data in database")).arg(currentData.id);
|
||||
break;
|
||||
}
|
||||
|
||||
existingEquipmentType = new EquipmentType(currentData);
|
||||
existingEquipmentType->id(dbEquipmentType.id);
|
||||
m_equipmentTypes.insert(existingEquipmentType->id(), existingEquipmentType);
|
||||
activeIds += existingEquipmentType->id();
|
||||
existingEquipmentType->id = dbEquipmentType.id;
|
||||
m_equipmentTypes.insert(existingEquipmentType->id, existingEquipmentType);
|
||||
activeIds += existingEquipmentType->id;
|
||||
bPublishData = true;
|
||||
}
|
||||
|
||||
INFO_LOG(m_logger) << "Modified EquipmentType with id " << existingEquipmentType->id() << " ?: " << bPublishData;
|
||||
INFO_LOG(m_logger) << "Modified EquipmentType with id " << existingEquipmentType->id << " ?: " << bPublishData;
|
||||
if (bPublishData)
|
||||
{
|
||||
if (!m_mainHandler->exAnyDts()->publish(*existingEquipmentType))
|
||||
{
|
||||
rep = Core::FunctionReplyObject(currentData.id(), tr_lts("dds", "Error publishing equipment type %1 to DDS")).arg(currentData.id());
|
||||
rep = Core::FunctionReplyObject(currentData.id, tr_lts("dds", "Error publishing equipment type %1 to DDS")).arg(currentData.id);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (request.deleteAll())
|
||||
if (request.deleteAll)
|
||||
{
|
||||
QHashIterator<int32_t,EquipmentType*> it(m_equipmentTypes);
|
||||
while (it.hasNext())
|
||||
{
|
||||
EquipmentType* et = it.next().value();
|
||||
if (activeIds.contains(et->id()))
|
||||
if (activeIds.contains(et->id))
|
||||
continue;
|
||||
|
||||
INFO_LOG(m_logger) << "Deleted in WHG " << et->id() << ", already marked as deleted?: " << et->deletedInWms();
|
||||
INFO_LOG(m_logger) << "Deleted in WHG " << et->id << ", already marked as deleted?: " << et->deletedInWms;
|
||||
|
||||
// alle, die nicht behandelt wurden -> deletedInWms
|
||||
// über alle iterieren
|
||||
if (et->deletedInWms())
|
||||
if (et->deletedInWms)
|
||||
continue;
|
||||
|
||||
et->deletedInWms(true);
|
||||
et->deletedInWms = true;
|
||||
if (!m_mainHandler->db()->update(toDb(*et)))
|
||||
{
|
||||
rep = Core::FunctionReplyObject(et->id(), tr_lts("dds", "Error updating equipment type with %1 data in database")).arg(et->id());
|
||||
rep = Core::FunctionReplyObject(et->id, tr_lts("dds", "Error updating equipment type with %1 data in database")).arg(et->id);
|
||||
break;
|
||||
}
|
||||
|
||||
if (!m_mainHandler->exAnyDts()->publish(*et))
|
||||
{
|
||||
rep = Core::FunctionReplyObject(et->id(), tr_lts("dds", "Error publishing equipment type %1 to DDS")).arg(et->id());
|
||||
rep = Core::FunctionReplyObject(et->id, tr_lts("dds", "Error publishing equipment type %1 to DDS")).arg(et->id);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -301,7 +301,7 @@ bool TypeHandling::TypeHandlerGlobal::isTypeUsed(int typeId) const
|
||||
const auto exercises = m_exmDtc->exercises();
|
||||
for (const ExerciseManagement::Exercise &ex : exercises)
|
||||
{
|
||||
const QString tblName = DBCommon::getExerciseTableName(QStringLiteral("ppm_participant"), ex.id());
|
||||
const QString tblName = DBCommon::getExerciseTableName(QStringLiteral("ppm_participant"), ex.id);
|
||||
//const QString stmt(QStringLiteral("SELECT count(*) FROM %1 WHERE type_id = %2").arg(tblName, QString::number(typeId)));
|
||||
|
||||
// Error occured => same as if type exists
|
||||
@@ -310,7 +310,7 @@ bool TypeHandling::TypeHandlerGlobal::isTypeUsed(int typeId) const
|
||||
|
||||
int count = q.value(0).toInt();
|
||||
|
||||
DEBUG_LOG(m_logger) << "exercise: " << ex.id() << ", count: " << count;
|
||||
DEBUG_LOG(m_logger) << "exercise: " << ex.id << ", count: " << count;
|
||||
if (count > 0)
|
||||
return true;
|
||||
}
|
||||
|
||||
+76
-76
@@ -46,14 +46,14 @@ bool MissionPlanHandler::init()
|
||||
|
||||
void MissionPlanHandler::onModifyMissionPlanRequest(const rti::core::SampleIdentity &cookie, const ModifyMissionPlanRequest &request)
|
||||
{
|
||||
Core::FunctionReplyObject reply = request.id() == 0 ? createMissionPlanRequest(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());
|
||||
Core::FunctionReplyObject reply = removeMissionPlanRequest(request.id);
|
||||
|
||||
m_mainHandler->ddsHandler()->fts()->removeMissionPlanReply(cookie, reply);
|
||||
}
|
||||
@@ -94,12 +94,12 @@ bool MissionPlanHandler::loadMissionPlansFromDb()
|
||||
for (const ParticipantManagement::Database::PpmMissionPlan &data : std::as_const(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);
|
||||
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
|
||||
@@ -120,14 +120,14 @@ bool MissionPlanHandler::loadMissionPlansFromDb()
|
||||
}
|
||||
|
||||
|
||||
missionPlan.items().reserve(itemsDbMap.size());
|
||||
missionPlan.items.reserve(itemsDbMap.size());
|
||||
for (const ParticipantManagement::Database::PpmMissionItem &item : std::as_const(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);
|
||||
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)
|
||||
@@ -135,36 +135,36 @@ bool MissionPlanHandler::loadMissionPlansFromDb()
|
||||
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);
|
||||
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)
|
||||
if (msa.fulfilled > 0)
|
||||
actionsFulfilled++;
|
||||
|
||||
if (latestFulfilled < msa.fulfilled())
|
||||
latestFulfilled = msa.fulfilled();
|
||||
if (latestFulfilled < msa.fulfilled)
|
||||
latestFulfilled = msa.fulfilled;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
msi.actionsFulfilled(actionsFulfilled);
|
||||
msi.fulfilled(latestFulfilled);
|
||||
msi.actionsFulfilled = actionsFulfilled;
|
||||
msi.fulfilled = latestFulfilled;
|
||||
|
||||
missionPlan.items().push_back(msi);
|
||||
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);
|
||||
m_objMissionPlans.insert(missionPlan.id, obj);
|
||||
|
||||
// publish mission plan data
|
||||
m_mainHandler->ddsHandler()->dts()->publish(missionPlan);
|
||||
@@ -179,15 +179,15 @@ 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)
|
||||
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();
|
||||
DEBUG_LOG(m_logger) << "uas with pid " << participantId << " is in mode: " << (int)uas.uasState;
|
||||
|
||||
return (uas.uasState() == ProjectDataManagement::UasState::UasState_Auto);
|
||||
return (uas.uasState == ProjectDataManagement::UasState::UasState_Auto);
|
||||
}
|
||||
|
||||
// stolen from Lts/Plugins/ParticipantManagement/Gui/ParticipantInfo/participant_info_dialog.cpp
|
||||
@@ -196,53 +196,53 @@ bool MissionPlanHandler::isUasCombatReady(int participantId)
|
||||
m_mainHandler->ddsHandler()->dtc()->waitForHistoricalDataDynamicParticipantData(3000);
|
||||
const auto data = m_mainHandler->ddsHandler()->dtc()->dynamicParticipantData(participantId);
|
||||
|
||||
if (data.participantId() == 0)
|
||||
if (data.participantId == 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
//Current State
|
||||
if (data.stateHistory().empty())
|
||||
if (data.stateHistory.empty())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
const auto &history = data.stateHistory();
|
||||
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);
|
||||
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())
|
||||
<< " time=" << si.stateTime
|
||||
<< " vulnerabilityBits=" << si.vulnerabilityBits
|
||||
<< " vulnerabilityKindId=" << si.vulnerabilityKindId;
|
||||
if (youngestState.stateTime < si.stateTime)
|
||||
youngestState = si;
|
||||
}
|
||||
|
||||
return (youngestState.vulnerabilityState() == ProjectDataManagement::VulnerabilityState::VulnerabilityState_CombatReady);
|
||||
return (youngestState.vulnerabilityState == ProjectDataManagement::VulnerabilityState::VulnerabilityState_CombatReady);
|
||||
}
|
||||
|
||||
Core::FunctionReplyObject MissionPlanHandler::createMissionPlanRequest(const ModifyMissionPlanRequest &request)
|
||||
{
|
||||
DEBUG_LOG(m_logger) <<" >> -- createMissionPlanRequest -- ";
|
||||
if (request.participantId() > 0 && !isUasParticipant(request.participantId()))
|
||||
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());
|
||||
return Core::FunctionReplyObject(tr_lts("dds", "Participant with id %1 is not a Uas participant.")).arg(request.participantId);
|
||||
}
|
||||
|
||||
if (!isUasInAutoMode(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());
|
||||
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()))
|
||||
if (!isUasCombatReady(request.participantId))
|
||||
{
|
||||
return Core::FunctionReplyObject(tr_lts("dds", "Uas with participant id %1 ------ not combat ready.")).arg(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
|
||||
@@ -254,7 +254,7 @@ Core::FunctionReplyObject MissionPlanHandler::createMissionPlanRequest(const Mod
|
||||
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());
|
||||
Core::FunctionReplyObject ret = obj->createMissionPlan(dbMissionPlan, request.items);
|
||||
if (ret.error())
|
||||
{
|
||||
delete obj;
|
||||
@@ -273,13 +273,13 @@ Core::FunctionReplyObject MissionPlanHandler::modifyMissionPlanRequest(const Mod
|
||||
/// 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());
|
||||
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());
|
||||
auto ret = obj->updateMissionPlan(dbMissionPlan, request.items);
|
||||
publishMissionPlan(obj->getMissionPlanData()); // publish mission plan
|
||||
return ret;
|
||||
}
|
||||
@@ -308,19 +308,19 @@ bool MissionPlanHandler::setCurrentMissionActionFulfilled(int participantId, con
|
||||
bool found = false;
|
||||
for (const auto &missionPlan : m_objMissionPlans.values())
|
||||
{
|
||||
if (missionPlan->missionPlan().participantId() == participantId && missionPlan->missionPlan().missionStart() <= m_mainHandler->currentTimeMSec())
|
||||
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 !!
|
||||
const std::vector< ParticipantManagement::MissionItem > items = missionPlan->missionPlan().items; // copy !!
|
||||
for (const auto &item : items)
|
||||
{
|
||||
for (auto &msa : item.actions())
|
||||
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())));
|
||||
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();
|
||||
INFO_LOG(m_logger) << ">> mission item: this mission name: " << thisMissionName << ", fulfilled: " << msa.fulfilled;
|
||||
|
||||
if (msa.fulfilled() > 0)
|
||||
if (msa.fulfilled > 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
@@ -330,12 +330,12 @@ bool MissionPlanHandler::setCurrentMissionActionFulfilled(int participantId, con
|
||||
continue;
|
||||
}
|
||||
|
||||
DEBUG_LOG(m_logger) << ">> ######### setMissionActionFulfilledRequest !!! item = " << item.itemNumber() << ", name = " << item.name() << ", missionPlan = " << missionPlan->missionPlan().id();
|
||||
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());
|
||||
req.actionNumber = msa.actionNumber;
|
||||
req.fulfilled = true;
|
||||
req.missionId = missionPlan->missionPlan().id;
|
||||
req.itemNumber = item.itemNumber;
|
||||
const auto res = setMissionActionFulfilledRequest(req);
|
||||
if (res.error())
|
||||
{
|
||||
@@ -371,9 +371,9 @@ bool MissionPlanHandler::setCurrentMissionActionFulfilled(int participantId, con
|
||||
|
||||
Core::FunctionReplyObject MissionPlanHandler::setMissionActionFulfilledRequest(const SetMissionActionFulfilledRequest &request)
|
||||
{
|
||||
DEBUG_LOG(m_logger)<<" -- [setMissionActionFulfilledRequest] req.missionId: "<<request.missionId();
|
||||
DEBUG_LOG(m_logger)<<" -- [setMissionActionFulfilledRequest] req.missionId: "<<request.missionId;
|
||||
Core::FunctionReplyObject ret;
|
||||
ObjectMissionPlan *obj = m_objMissionPlans.value(request.missionId(), nullptr);
|
||||
ObjectMissionPlan *obj = m_objMissionPlans.value(request.missionId, nullptr);
|
||||
if (!obj)
|
||||
return ret;
|
||||
ret = obj->setMissionActionFulfilled(request, m_mainHandler->currentTimeMSec());
|
||||
@@ -403,9 +403,9 @@ bool MissionPlanHandler::isUasParticipant(int participantId) const
|
||||
int MissionPlanHandler::getNumberOfActionFulfilled(const MissionItem &msi) const
|
||||
{
|
||||
int count = 0;
|
||||
for (auto action : msi.actions())
|
||||
for (auto action : msi.actions)
|
||||
{
|
||||
if (action.fulfilled() > 0)
|
||||
if (action.fulfilled > 0)
|
||||
count++;
|
||||
}
|
||||
return count;
|
||||
@@ -415,26 +415,26 @@ void MissionPlanHandler::setLatestFulfilledItem(MissionPlan &missionPlan)
|
||||
{
|
||||
int count = 0;
|
||||
int64_t latestTime = 0;
|
||||
for (auto item : missionPlan.items())
|
||||
for (auto item : missionPlan.items)
|
||||
{
|
||||
if (item.actionsFulfilled() > 0)
|
||||
if (item.actionsFulfilled > 0)
|
||||
count++;
|
||||
|
||||
if (latestTime < item.fulfilled())
|
||||
latestTime = item.fulfilled();
|
||||
if (latestTime < item.fulfilled)
|
||||
latestTime = item.fulfilled;
|
||||
|
||||
missionPlan.itemsFulfilled(count);
|
||||
missionPlan.fulfilled(latestTime);
|
||||
missionPlan.itemsFulfilled = count;
|
||||
missionPlan.fulfilled = latestTime;
|
||||
}
|
||||
}
|
||||
|
||||
int64_t MissionPlanHandler::getLastestFulfilledAction(const MissionItem &msi) const
|
||||
{
|
||||
int64_t latestTime = 0;
|
||||
for (auto action : msi.actions())
|
||||
for (auto action : msi.actions)
|
||||
{
|
||||
if (action.fulfilled() > latestTime)
|
||||
latestTime = action.fulfilled();
|
||||
if (action.fulfilled > latestTime)
|
||||
latestTime = action.fulfilled;
|
||||
}
|
||||
|
||||
return latestTime;
|
||||
|
||||
+105
-105
@@ -25,29 +25,29 @@ ObjectMissionPlan::ObjectMissionPlan(const std::shared_ptr<DdsHandler> &ddsHandl
|
||||
, m_missionplan(missionPlan)
|
||||
, m_logger(getLogger("ObjectMissionPlan"))
|
||||
{
|
||||
DEBUG_LOG(m_logger)<<" - ctor ObjectMissionPlan: planId: "<<m_missionplan.id();
|
||||
DEBUG_LOG(m_logger)<<" - ctor ObjectMissionPlan: planId: "<<m_missionplan.id;
|
||||
|
||||
}
|
||||
|
||||
int32_t ObjectMissionPlan::id() const
|
||||
{
|
||||
return m_missionplan.id();
|
||||
return m_missionplan.id;
|
||||
}
|
||||
|
||||
int32_t ObjectMissionPlan::participantId() const
|
||||
{
|
||||
return m_missionplan.participantId();
|
||||
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();
|
||||
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;
|
||||
}
|
||||
@@ -56,14 +56,14 @@ Database::PpmMissionPlan ObjectMissionPlan::toDbMissionPlan(const ModifyMissionP
|
||||
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());
|
||||
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;
|
||||
}
|
||||
@@ -74,7 +74,7 @@ MissionPlan ObjectMissionPlan::getMissionPlanData() const
|
||||
}
|
||||
|
||||
void ObjectMissionPlan::setDbMissionItems(const QMap<int, ParticipantManagement::Database::PpmMissionItem> &dbItems,
|
||||
const QMap<int, Database::PpmMissionAction> &dbActions)
|
||||
const QMultiMap<int, Database::PpmMissionAction> &dbActions)
|
||||
{
|
||||
m_mapMissionItems.clear();
|
||||
m_dbMissionActions.clear();
|
||||
@@ -82,24 +82,24 @@ void ObjectMissionPlan::setDbMissionItems(const QMap<int, ParticipantManagement:
|
||||
for (const ParticipantManagement::Database::PpmMissionItem &item : std::as_const(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);
|
||||
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);
|
||||
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);
|
||||
}
|
||||
}
|
||||
@@ -140,26 +140,26 @@ Core::FunctionReplyObject ObjectMissionPlan::createMissionPlan(Database::PpmMiss
|
||||
{
|
||||
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());
|
||||
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())
|
||||
actionsVec.reserve(item.actions.size());
|
||||
for (auto &action : item.actions)
|
||||
{
|
||||
action.planId(newMissionPlan.id);
|
||||
action.planId = newMissionPlan.id;
|
||||
Database::PpmMissionAction dbAction;
|
||||
dbAction.missionActionTypeId = action.actionType();
|
||||
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();
|
||||
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"));
|
||||
|
||||
@@ -169,21 +169,21 @@ Core::FunctionReplyObject ObjectMissionPlan::createMissionPlan(Database::PpmMiss
|
||||
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);
|
||||
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 &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();
|
||||
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 !!";
|
||||
@@ -231,25 +231,25 @@ Core::FunctionReplyObject ObjectMissionPlan::updateMissionPlan(Database::PpmMiss
|
||||
{
|
||||
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());
|
||||
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())
|
||||
actionsVec.reserve(item.actions.size());
|
||||
for (auto &action : item.actions)
|
||||
{
|
||||
action.planId(newMissionPlan.id);
|
||||
action.planId = newMissionPlan.id;
|
||||
Database::PpmMissionAction dbAction;
|
||||
dbAction.missionActionTypeId = action.actionType();
|
||||
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();
|
||||
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"));
|
||||
|
||||
@@ -260,19 +260,19 @@ Core::FunctionReplyObject ObjectMissionPlan::updateMissionPlan(Database::PpmMiss
|
||||
}//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);
|
||||
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 !!";
|
||||
DEBUG_LOG(m_logger)<< ">> [UPDATE] mission plan with id( "<<m_missionplan.id<<" ) Updated !!";
|
||||
|
||||
return Core::FunctionReplyObject(m_missionplan.id());
|
||||
return Core::FunctionReplyObject(m_missionplan.id);
|
||||
}
|
||||
|
||||
Core::FunctionReplyObject ObjectMissionPlan::removeMissionPlan(int id)
|
||||
@@ -305,33 +305,33 @@ Core::FunctionReplyObject ObjectMissionPlan::setMissionActionFulfilled(SetMissio
|
||||
return Core::FunctionReplyObject("");
|
||||
}
|
||||
|
||||
if (req.missionId() != m_missionplan.id())
|
||||
if (req.missionId != m_missionplan.id)
|
||||
{
|
||||
QString error = QStringLiteral("Wrong missionPlan Object caught Request: %1 / currPlanId: %2").arg(req.missionId()).arg(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)
|
||||
if (req.actionNumber < 0 && req.itemNumber < 0)
|
||||
{
|
||||
m_missionplan.aborted(true);
|
||||
m_missionplan.aborted = true;
|
||||
return setMissionPlanAborted(true);
|
||||
}
|
||||
|
||||
auto &dbActions = m_dbMissionActions[req.itemNumber()]; //[elemNum][actionNum]
|
||||
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
|
||||
|| 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());
|
||||
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()];
|
||||
Database::PpmMissionAction &dbAction = dbActions[req.actionNumber];
|
||||
dbAction.fulfilled = QDateTime::fromMSecsSinceEpoch(currentTimeMSec);
|
||||
|
||||
if (!m_db->update(dbAction))
|
||||
@@ -348,11 +348,11 @@ Core::FunctionReplyObject ObjectMissionPlan::setMissionActionFulfilled(SetMissio
|
||||
//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
|
||||
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
|
||||
@@ -360,27 +360,27 @@ Core::FunctionReplyObject ObjectMissionPlan::setMissionActionFulfilled(SetMissio
|
||||
int numbItemFulfilled = 0;
|
||||
for(const auto &item : m_mapMissionItems)
|
||||
{
|
||||
if (item.actionsFulfilled() == static_cast<int>(item.actions().size()))
|
||||
if (item.actionsFulfilled == static_cast<int>(item.actions.size()))
|
||||
numbItemFulfilled++;
|
||||
}
|
||||
m_missionplan.itemsFulfilled(numbItemFulfilled);
|
||||
m_missionplan.fulfilled(dbAction.fulfilled.toMSecsSinceEpoch());
|
||||
m_missionplan.itemsFulfilled = numbItemFulfilled;
|
||||
m_missionplan.fulfilled = dbAction.fulfilled.toMSecsSinceEpoch();
|
||||
|
||||
|
||||
return Core::FunctionReplyObject(m_missionplan.id());
|
||||
return Core::FunctionReplyObject(m_missionplan.id);
|
||||
}
|
||||
|
||||
Core::FunctionReplyObject ObjectMissionPlan::setMissionPlanAborted(bool state)
|
||||
{
|
||||
DEBUG_LOG(m_logger)<<" -- [setMissionPlanAborted] abort mission plan: "<<m_missionplan.id();
|
||||
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.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;
|
||||
|
||||
|
||||
@@ -392,7 +392,7 @@ Core::FunctionReplyObject ObjectMissionPlan::setMissionPlanAborted(bool state)
|
||||
return Core::FunctionReplyObject(error.toStdString().c_str());
|
||||
}
|
||||
|
||||
return Core::FunctionReplyObject(m_missionplan.id());
|
||||
return Core::FunctionReplyObject(m_missionplan.id);
|
||||
}
|
||||
|
||||
} // namespace UasHandling
|
||||
|
||||
+1
-1
@@ -36,7 +36,7 @@ public:
|
||||
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 QMultiMap <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);
|
||||
|
||||
+22
-22
@@ -15,21 +15,21 @@ 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;
|
||||
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();
|
||||
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;
|
||||
@@ -53,7 +53,7 @@ void Uas::unlinkUas()
|
||||
|
||||
void Uas::setState(const ProjectDataManagement::UasState &newState)
|
||||
{
|
||||
m_data.uasStateId = newState.underlying();
|
||||
m_data.uasStateId = static_cast<int>(newState);
|
||||
}
|
||||
int32_t Uas::id() const
|
||||
{
|
||||
@@ -74,15 +74,15 @@ UAS Uas::toDdsUas() const
|
||||
{
|
||||
ParticipantManagement::UAS result;
|
||||
|
||||
result.id(m_data.id);
|
||||
result.deviceIdentifier(m_data.deviceIdentifier.toStdString());
|
||||
result.uasState(static_cast<ProjectDataManagement::UasState>(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);
|
||||
result.id = m_data.id;
|
||||
result.deviceIdentifier = m_data.deviceIdentifier.toStdString();
|
||||
result.uasState = static_cast<ProjectDataManagement::UasState>(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;
|
||||
}
|
||||
|
||||
+25
-25
@@ -83,7 +83,7 @@ bool UasHandler::init()
|
||||
//------------------------------------------------------------------------------------------
|
||||
void UasHandler::onCreateModifyUasRequest(const rti::core::SampleIdentity &cookie, const CreateModifyUasRequest &request)
|
||||
{
|
||||
Core::FunctionReplyObject reply = request.id() == 0 ? createUas(request) : modifyUas(request);
|
||||
Core::FunctionReplyObject reply = request.id == 0 ? createUas(request) : modifyUas(request);
|
||||
|
||||
m_mainHandler->exAnyFts()->createModifyUasReply(cookie, reply);
|
||||
}
|
||||
@@ -101,18 +101,18 @@ Core::FunctionReplyObject UasHandler::removeUas(const RemoveUasRequest &request)
|
||||
{
|
||||
DEBUG_LOG(m_logger) << "onRemoveUasRequest " << request;
|
||||
|
||||
if (request.id() < 0)
|
||||
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());
|
||||
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());
|
||||
.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();
|
||||
DEBUG_LOG(m_logger) << "Removing UAS with ID " << request.id;
|
||||
|
||||
return removeUas(uasToDelete);
|
||||
}
|
||||
@@ -153,13 +153,13 @@ Core::FunctionReplyObject UasHandler::createUas(const CreateModifyUasRequest &re
|
||||
|
||||
Database::PpmUas dbUas;
|
||||
|
||||
dbUas.deviceIdentifier = QString::fromStdString(request.deviceIdentifier());
|
||||
dbUas.uasStateId = ProjectDataManagement::UasState::UasState_Undefined;
|
||||
dbUas.participantId = request.participantId();
|
||||
dbUas.exerciseId = request.exerciseId();
|
||||
dbUas.hostname = QString::fromStdString(request.hostname());
|
||||
dbUas.hostport = request.hostport();
|
||||
dbUas.useTcp = request.useTcp();
|
||||
dbUas.deviceIdentifier = QString::fromStdString(request.deviceIdentifier);
|
||||
dbUas.uasStateId = static_cast<int>(ProjectDataManagement::UasState::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"))
|
||||
@@ -185,21 +185,21 @@ Core::FunctionReplyObject UasHandler::createUas(const CreateModifyUasRequest &re
|
||||
//------------------------------------------------------------------------------------------
|
||||
Core::FunctionReplyObject UasHandler::modifyUas(const CreateModifyUasRequest &request)
|
||||
{
|
||||
if (!m_uass.contains(request.id()))
|
||||
if (!m_uass.contains(request.id))
|
||||
{
|
||||
QString error = QStringLiteral("Uas topic with id %1 not present. Not possible to modify it.").arg(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());
|
||||
Uas *uas = m_uass.value(request.id);
|
||||
|
||||
// Check if Hostname and Hostport already existing
|
||||
if (hostNameHostPortExists(QString::fromStdString(request.hostname()), request.hostport(), uas->id()))
|
||||
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());
|
||||
.arg(request.hostname).arg(request.hostport);
|
||||
|
||||
if (!uas->hasChanges(request))
|
||||
{
|
||||
@@ -248,16 +248,16 @@ void UasHandler::onExerciseChanged(const ExerciseManagement::Exercise &data, Dat
|
||||
{
|
||||
Q_UNUSED(mod)
|
||||
|
||||
if (data.state() != ExerciseManagement::ExerciseState::Stopped &&
|
||||
data.state() != ExerciseManagement::ExerciseState::Terminated &&
|
||||
data.state() != ExerciseManagement::ExerciseState::Unknown )
|
||||
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())
|
||||
if (uasData.exerciseId != data.id)
|
||||
continue;
|
||||
|
||||
uas->unlinkUas();
|
||||
@@ -268,16 +268,16 @@ void UasHandler::onExerciseChanged(const ExerciseManagement::Exercise &data, Dat
|
||||
|
||||
void UasHandler::onUASRadioLinkConnectionStatusChanged(const UASRadioLinkConnectionStatus &data, DataModification mod)
|
||||
{
|
||||
if (data.id() <= 0)
|
||||
if (data.id <= 0)
|
||||
return;
|
||||
if (!m_uass.contains(data.id()))
|
||||
if (!m_uass.contains(data.id))
|
||||
return;
|
||||
|
||||
auto uas = m_uass.value(data.id());
|
||||
auto uas = m_uass.value(data.id);
|
||||
if (mod == DataModification::eRemoved)
|
||||
uas->setState(ProjectDataManagement::UasState::UasState_Undefined);
|
||||
else
|
||||
uas->setState(data.uasState());
|
||||
uas->setState(data.uasState);
|
||||
m_mainHandler->exAnyDts()->publish(uas->toDdsUas());
|
||||
m_mainHandler->db()->update(uas->toDbUas());
|
||||
}
|
||||
|
||||
+6
-6
@@ -52,12 +52,12 @@ LtsWebSocket::ReplyMessage *DataManager::ocPositionData(int equipmentNr, const Q
|
||||
}
|
||||
ParticipantPosition pos = m_ppmDtc->participantPosition(m_ppmDtc->participantIdByEquipmentNumber(equipmentNr));
|
||||
QJsonObject obj;
|
||||
obj[QStringLiteral("participantId")] = pos.participantId();
|
||||
obj[QStringLiteral("lat")] = pos.pos().lat();
|
||||
obj[QStringLiteral("lon")] = pos.pos().lon();
|
||||
obj[QStringLiteral("height")] = pos.pos().z();
|
||||
obj[QStringLiteral("roomId")] = pos.roomId();
|
||||
obj[QStringLiteral("buildingId")] = pos.buildingId();
|
||||
obj[QStringLiteral("participantId")] = pos.participantId;
|
||||
obj[QStringLiteral("lat")] = pos.pos.lat;
|
||||
obj[QStringLiteral("lon")] = pos.pos.lon;
|
||||
obj[QStringLiteral("height")] = pos.pos.z;
|
||||
obj[QStringLiteral("roomId")] = pos.roomId;
|
||||
obj[QStringLiteral("buildingId")] = pos.buildingId;
|
||||
|
||||
return new ParticipantManagement::WebSocketInterface::Messages::OcPositionData(obj, uuid);
|
||||
}
|
||||
|
||||
+19
-19
@@ -20,36 +20,36 @@ inline Type convert(const PpmType &data)
|
||||
{
|
||||
Type ddsData;
|
||||
|
||||
ddsData.id(data.id);
|
||||
ddsData.typeClass(data.typeClassId);
|
||||
ddsData.equipmentTypeId(data.equipmentTypeId.isNull() ? 0 : data.equipmentTypeId.toInt());
|
||||
ddsData.name(data.name.toStdString());
|
||||
ddsData.symbol(data.symbol.toStdString());
|
||||
ddsData.radioCount(data.radioCount);
|
||||
ddsData.hierarchyLevel(data.hierarchyLevel);
|
||||
ddsData.isDeleted(data.isDeleted);
|
||||
ddsData.id = data.id;
|
||||
ddsData.typeClass = data.typeClassId;
|
||||
ddsData.equipmentTypeId = data.equipmentTypeId.isNull() ? 0 : data.equipmentTypeId.toInt();
|
||||
ddsData.name = data.name.toStdString();
|
||||
ddsData.symbol = data.symbol.toStdString();
|
||||
ddsData.radioCount = data.radioCount;
|
||||
ddsData.hierarchyLevel = data.hierarchyLevel;
|
||||
ddsData.isDeleted = data.isDeleted;
|
||||
#ifdef Q_OS_WIN
|
||||
ddsData.disEntities(data.disEntities());
|
||||
ddsData.disEntities = data.disEntities();
|
||||
#else
|
||||
ddsData.disEntities(LtsUtils::convert<std::vector<rti::core::int64>>(data.disEntities()));
|
||||
ddsData.disEntities = data.disEntities();
|
||||
#endif
|
||||
ddsData.properties(data.properties.toStdString());
|
||||
ddsData.properties = data.properties.toStdString();
|
||||
|
||||
return ddsData;
|
||||
}
|
||||
inline EquipmentType convert(const PpmEquipmentType &db)
|
||||
{
|
||||
EquipmentType et;
|
||||
et.id(db.id);
|
||||
et.name(db.name.toStdString());
|
||||
et.id = db.id;
|
||||
et.name = db.name.toStdString();
|
||||
{ // equipment value are save in the db as int, but in dds unsigned short is used.
|
||||
et.minEquipNo(db.minEquipNo < USHRT_MAX ? db.minEquipNo : USHRT_MAX);
|
||||
et.maxEquipNo(db.maxEquipNo < USHRT_MAX ? db.maxEquipNo : USHRT_MAX);
|
||||
et.minEquipNo = db.minEquipNo < USHRT_MAX ? db.minEquipNo : USHRT_MAX;
|
||||
et.maxEquipNo = db.maxEquipNo < USHRT_MAX ? db.maxEquipNo : USHRT_MAX;
|
||||
}
|
||||
et.traVulnerabilityModelId(db.traVulnerabilityModelId);
|
||||
et.traPlayerTypeId(db.traPlayerTypeId);
|
||||
et.wmsTypeClass(db.wmsTypeClassId);
|
||||
et.deletedInWms(db.deletedInWms);
|
||||
et.traVulnerabilityModelId = db.traVulnerabilityModelId;
|
||||
et.traPlayerTypeId = db.traPlayerTypeId;
|
||||
et.wmsTypeClass = db.wmsTypeClassId;
|
||||
et.deletedInWms = db.deletedInWms;
|
||||
return et;
|
||||
}
|
||||
|
||||
|
||||
@@ -40,9 +40,9 @@ StateInformation youngestStateInformation(const std::vector<ParticipantManagemen
|
||||
// for (const ParticipantManagement::StateInformation &si : std::as_const(stateList))
|
||||
// {
|
||||
// if (si.originatorId() == 0
|
||||
// && si.originatorType() == ProjectDataManagement::StateChangeOriginator::ExerciseControl
|
||||
// && (si.vulnerabilityState() == ProjectDataManagement::VulnerabilityState::CatastrophicKill
|
||||
// || si.vulnerabilityState() == ProjectDataManagement::VulnerabilityState::CombatReady)
|
||||
// && si.originatorType() == ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_ExerciseControl
|
||||
// && (si.vulnerabilityState() == ProjectDataManagement::VulnerabilityState::VulnerabilityState_CatastrophicKill
|
||||
// || si.vulnerabilityState() == ProjectDataManagement::VulnerabilityState::VulnerabilityState_CombatReady)
|
||||
// )
|
||||
// readyToDebug = true;
|
||||
// }
|
||||
@@ -66,7 +66,7 @@ StateInformation youngestStateInformation(const std::vector<ParticipantManagemen
|
||||
// if (readyToDebug)
|
||||
// debug = true;
|
||||
|
||||
// qWarning() << "WARNING: StateInformation with state" << (int)left.vulnerabilityState().underlying() << "has the same stateTime as StateInformation with state" << (int)right.vulnerabilityState().underlying();
|
||||
// qWarning() << "WARNING: StateInformation with state" << (int)left.vulnerabilityState() << "has the same stateTime as StateInformation with state" << (int)right.vulnerabilityState();
|
||||
|
||||
// sort by state if time is the same (higher state = winner)
|
||||
return (left.vulnerabilityState > right.vulnerabilityState);
|
||||
|
||||
+3
-3
@@ -194,7 +194,7 @@ int DtcImplCustom::participantIdByEquipmentNumber(int equipmentNumber) const
|
||||
|
||||
for (const auto &sample : m_dtcParticipant->readAlive())
|
||||
{
|
||||
if (sample.data().equipmentNumber.is_set() && sample.data().equipmentNumber.get() == equipmentNumber)
|
||||
if (sample.data().equipmentNumber.has_value() && sample.data().equipmentNumber.get() == equipmentNumber)
|
||||
return sample.data().id;
|
||||
}
|
||||
|
||||
@@ -210,7 +210,7 @@ int DtcImplCustom::equipmentNumberByParticipantId(int participantId) const
|
||||
{
|
||||
if (sample.data().id == participantId)
|
||||
{
|
||||
if (sample.data().equipmentNumber.is_set())
|
||||
if (sample.data().equipmentNumber.has_value())
|
||||
return sample.data().equipmentNumber.get();
|
||||
}
|
||||
}
|
||||
@@ -477,7 +477,7 @@ QVector<TemplateParticipant> DtcImplCustom::inferiorTemplates(int templateId)
|
||||
const TemplateParticipant participant = templateParticipant(templateId);
|
||||
retVector.append(participant);
|
||||
|
||||
if (participant.inferiorIds.is_set())
|
||||
if (participant.inferiorIds.has_value())
|
||||
{
|
||||
retVector.reserve(participant.inferiorIds.get().size() + retVector.size());
|
||||
for (int inferiorId : participant.inferiorIds.get())
|
||||
|
||||
+4
-4
@@ -62,11 +62,11 @@ bool WebSocketHandler::init(const QPair<quint16, quint16> &portRange)
|
||||
bool WebSocketHandler::sendTelegramInternal(const ParticipantPosition &pos, int eqNo) const
|
||||
{
|
||||
QJsonObject obj;
|
||||
obj[QStringLiteral("participantId")] = pos.participantId();
|
||||
obj[QStringLiteral("participantId")] = pos.participantId;
|
||||
obj[QStringLiteral("equipmentNumber")] = eqNo;
|
||||
obj[QStringLiteral("lat")] = pos.pos().lat();
|
||||
obj[QStringLiteral("lon")] = pos.pos().lon();
|
||||
obj[QStringLiteral("height")] = pos.pos().z();
|
||||
obj[QStringLiteral("lat")] = pos.pos.lat;
|
||||
obj[QStringLiteral("lon")] = pos.pos.lon;
|
||||
obj[QStringLiteral("height")] = pos.pos.z;
|
||||
|
||||
const QString jsonStr = QString::fromUtf8(QJsonDocument(obj).toJson(QJsonDocument::Compact));
|
||||
|
||||
|
||||
Reference in new issue
Block a user