qt5-legatus-legacy/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 "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().is_set())
  {
    newData.sent() = request.sent().get();
    newData.requester() = request.requester(); // ! Requester is only sent, when data gets sent.
  }
  if (request.received().is_set())
    newData.received() = request.received().get();
  if (request.activated().is_set())
  {
    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 : qAsConst(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 : qAsConst(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 : qAsConst(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 : qAsConst(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