qt-migration-legatus/qt6-after/qt6-migrated-legatus/Lts/Services/AudioVideoManagement/handler_frequency_planning_status.cpp

/**
  * Handler for Frequency Planning Status
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Malte Diers, ESCS, 23-01-10
  */

#include "handler_frequency_planning_status.h"
#include <utility>
#include "object_frequency_planning_status.h"

#include "avm_db.h"

namespace AudioVideoManagement
{


//--------------------------------------------------------------------------------------------------
static FrequencyPlanningStatus convert(const ModifyFrequencyPlanningStatusRequest &request, const FrequencyPlanningStatus &oldData)
{
  Q_ASSERT(request.client == oldData.client);

  FrequencyPlanningStatus newData(oldData);
  if (!oldData.uuid.empty())
  {
    if (oldData.uuid != request.uuid)
      WARNING_LOG(getLogger("HandlerFrequencyPlanningStatus")) << "WARNING: Same client has concurrent GetConfigCNR requests.";
  }
  newData.uuid = request.uuid.empty() ? oldData.uuid : request.uuid;
  newData.id = oldData.id;
  if (request.sent.has_value())
  {
    newData.sent = request.sent.get();
    newData.requester = request.requester; // ! Requester is only sent, when data gets sent.
  }
  if (request.received.has_value())
    newData.received = request.received.get();
  if (request.activated.has_value())
  {
    newData.activated = request.activated.get();
    newData.requester = request.requester; // ! Requester is only sent, when data gets activated.
  }
  newData.isActive = request.isActive;
  newData.content = request.content;
  newData.reason = request.reason;
  return newData;
}

HandlerFrequencyPlanningStatus::HandlerFrequencyPlanningStatus(Interface::Dts *dts, Interface::Fts *fts, DatabaseInterface *db)
  : Interface::Fts::ModifyFrequencyPlanningStatusRequestHandler(nullptr)
  , Interface::Fts::ClearFrequencyPlanningStatusRequestHandler(nullptr)
  , Interface::Fts::RemoveFrequencyPlanningStatusByClientRequestHandler(nullptr)
  , m_dts(dts)
  , m_fts(fts)
  , m_db(db)
  , m_logger(getLogger("HandlerFrequencyPlanningStatus"))
{
  Q_ASSERT(dts);
  Q_ASSERT(fts);
  Q_ASSERT(db);
  m_fts->setModifyFrequencyPlanningStatusRequestHandler(this);
  m_fts->setClearFrequencyPlanningStatusRequestHandler(this);
  m_fts->setRemoveFrequencyPlanningStatusByClientRequestHandler(this);

}

//--------------------------------------------------------------------------------------------------
HandlerFrequencyPlanningStatus::~HandlerFrequencyPlanningStatus()
{
}

//--------------------------------------------------------------------------------------------------
bool HandlerFrequencyPlanningStatus::init()
{
  QVector<Database::AvmFrequencyPlanningStatus> dataVec;
  // read all HandlerFrequencyPlanningStatus Data from database
  if (!m_db->select(dataVec))
  {
    ERROR_LOG(m_logger) << "Error reading data from database!";
    return false;
  }

  // create objects
  for (const Database::AvmFrequencyPlanningStatus &data : std::as_const(dataVec))
  {
    FrequencyPlanningStatus ddsData = ObjectFrequencyPlanningStatus::toDdsData(data);
    ObjectFrequencyPlanningStatus *ifs(new ObjectFrequencyPlanningStatus(m_dts, m_db));
    Core::FunctionReplyObject ret = ifs->createObject(ddsData);
    if (ret.error())
    {
      delete ifs;
      ERROR_LOG(m_logger) << ret();
      return false;
    }
    m_data.insert(ifs->getData().client, ifs);
  }
  return true;
}

//--------------------------------------------------------------------------------------------------
void HandlerFrequencyPlanningStatus::onModifyFrequencyPlanningStatusRequest(const rti::core::SampleIdentity &cookie,
                                                const ModifyFrequencyPlanningStatusRequest &request)
{
  DEBUG_LOG(m_logger) << "onModifyFrequencyPlanningStatusRequest: " << request;
  auto ret = m_data.contains(request.client) ? frequencyPlanningStatusModifyRequest(request) : frequencyPlanningStatusCreateRequest(request);
  if (ret.error())
    WARNING_LOG(m_logger) << ret();
  m_fts->modifyFrequencyPlanningStatusReply(cookie, ret);
}

void HandlerFrequencyPlanningStatus::onClearFrequencyPlanningStatusRequest(const rti::core::SampleIdentity &cookie, const ClearFrequencyPlanningStatusRequest &request)
{
  Q_UNUSED(request);
  Core::FunctionReplyObject ret;
  for (ObjectFrequencyPlanningStatus *ifs : std::as_const(m_data))
  {
    ret = ifs->clearValues();
    if (ret.error())
      break;
  }
  m_fts->clearFrequencyPlanningStatusReply(cookie, ret);
}

void HandlerFrequencyPlanningStatus::onRemoveFrequencyPlanningStatusByClientRequest(const rti::core::SampleIdentity &cookie, const RemoveFrequencyPlanningStatusByClientRequest &request)
{
  Core::FunctionReplyObject ret;
  QVector<int> clients;
  for (ObjectFrequencyPlanningStatus *ifs : std::as_const(m_data))
  {
    if (request.client == 0 || ifs->getData().client == request.client)
    {
      int client = ifs->getData().client;
      ret = ifs->removeObject();
      if (ret.error())
        ERROR_LOG(m_logger) << ret();
      else
        clients << client;
    }
  }
  for (int client : std::as_const(clients))
  {
    // delete ObjectVideoReceiver
    delete m_data[client];
    m_data.remove(client);
  }

  m_fts->removeFrequencyPlanningStatusByClientReply(cookie, ret);
}

//--------------------------------------------------------------------------------------------------
Core::FunctionReplyObject HandlerFrequencyPlanningStatus::frequencyPlanningStatusModifyRequest(const ModifyFrequencyPlanningStatusRequest &request)
{
  ObjectFrequencyPlanningStatus *ifs = m_data.value(request.client);
  if (ifs == nullptr)
    return Core::FunctionReplyObject(request.id, tr_lts("dds", "Video Team with id %1 not found")).arg(request.id);

  FrequencyPlanningStatus   ddsData = convert(request, ifs->getData());

  Core::FunctionReplyObject ret = ifs->updateObject(ddsData);
  return ret;
}

//--------------------------------------------------------------------------------------------------
Core::FunctionReplyObject HandlerFrequencyPlanningStatus::frequencyPlanningStatusCreateRequest(const ModifyFrequencyPlanningStatusRequest &request)
{
  ObjectFrequencyPlanningStatus *ifs = new ObjectFrequencyPlanningStatus(m_dts, m_db);

  Core::FunctionReplyObject ret = ifs->createObjectFromDDS(request);

  if (ret.error())
    delete ifs;
  else
    m_data.insert(ifs->getData().client, ifs);

  return ret;
}

} // Namespace