qt-migration-legatus/qt6-after/qt6-migrated-legatus/Lts/Services/PresentationManagement/object_presentation.cpp

/**
  * @RDE_HEADER@
  * ISM Object Main Structure Element
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Iuliana Ojog, SLSE, 2016-11-26
  */

#include "object_presentation.h"
#include <utility>
#include "initialization.h"
#include "dds_handler.h"
#include <ngldb/dbtransaction.h>

namespace PresentationManagement
{
//----------------------------------------------------------------------------------------------------
ObjectPresentation::ObjectPresentation(Initialization *mainHandler)
  : m_mainHandler(mainHandler)
{
}

ObjectPresentation::ObjectPresentation(const Presentation &data, Initialization *mainHandler)
  : m_mainHandler(mainHandler)
  , m_data(data)
{
}

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

//------------------------------------------------------------------------------------------------------------
bool ObjectPresentation::isValid() const
{
  return m_data.id() > 0;
}

void ObjectPresentation::addPresentationContent(PresentationContent &&data)
{
  m_content.push_back(std::move(data));
}

//------------------------------------------------------------------------------------------------------------
Core::FunctionReplyObject ObjectPresentation::createObject(const PresentationModifyRequest &request)
{
  m_data = Presentation();
  m_content.clear();

  m_data.name(request.name());
  m_data.description(request.description());
  m_data.operatorId(request.operatorId());
  m_data.lastModified(request.lastModified());

  m_content = request.content();
  //for(auto it = request.content().begin(); it != request.content().end(); ++it)
  //  m_content.append(*it);

  DBTransaction trans(m_mainHandler->db()->database());

  // Insert Presentation
  Database::PrePresentation dbData(toDbData(m_data));
  if (!m_mainHandler->db()->insert(dbData))
    return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting Presentation-data into database"));
  m_data.id(dbData.id);

  // Insert PresentationContent
  for (PresentationContent &conData : m_content)
  {
    conData.presentationId(m_data.id());

    Database::PrePresentationContent conDbData = toDbData(conData);
    conDbData.id = 0;
    conDbData.presentationId = m_data.id();

    if (!m_mainHandler->db()->insert(conDbData))
      return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting PresentationContent-data into database"));
    else
    {
      DEBUG_LOG() << "New presentation content id : " << conDbData.id;
      conData.id(conDbData.id);
    }
  }

  DEBUG_LOG() << "New Id: " << m_data.id();
  trans.commit();

  onPublishData();

  return Core::FunctionReplyObject(m_data.id());
}

//------------------------------------------------------------------------------------------------------------
Core::FunctionReplyObject ObjectPresentation::updateObject(const PresentationModifyRequest &request)
{
  if (!isValid())
    return Core::FunctionReplyObject(request.id(), tr_lts("dds", "Object not valid/blocked"));

  m_data.id(request.id());
  m_data.name(request.name());
  m_data.description(request.description());
  m_data.operatorId(request.operatorId());
  m_data.lastModified(request.lastModified());
  m_data.fileStatus(request.fileStatus());

  DBTransaction trans(m_mainHandler->db()->database());

  Database::PrePresentation dbData(toDbData(m_data));
  if (!m_mainHandler->db()->update(dbData))
    return Core::FunctionReplyObject(m_data.id(), tr_lts("dds", "Error updating Presentation-data into database"));

  for (const auto &content : std::as_const(m_content))
  {
    if (m_mainHandler->db()->removePrePresentationContent(content.id()))
      DEBUG_LOG() << "Removed presentation content id " << content.id();
    else
      ERROR_LOG() << "Failed to remove presentation content id " << content.id();
  }

  m_content = request.content();
  for (PresentationContent &conData : m_content)
  {
    conData.presentationId(m_data.id());

    Database::PrePresentationContent conDbData = toDbData(conData);
    conDbData.presentationId = m_data.id();
    conDbData.id = 0;

    if (!m_mainHandler->db()->insert(conDbData))
      return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting PresentationContent-data into database"));
    else
    {
      DEBUG_LOG() << "New presentation content id : " << conDbData.id;
      conData.id(conDbData.id);
    }

  }

  trans.commit();

  onPublishData();

  return Core::FunctionReplyObject(m_data.id());
}

//------------------------------------------------------------------------------------------------------------
Core::FunctionReplyObject ObjectPresentation::removeObject()
{
  // remove also presentationContent data via foreign key
  if (!m_mainHandler->db()->removePrePresentation(m_data.id()))
    return Core::FunctionReplyObject(m_data.id(), tr_lts("dds", "Presentation with id %1 can not be removed from DB")).arg(m_data.id());

  int id = m_data.id();
  m_content.clear();
  m_data = Presentation();

  return Core::FunctionReplyObject(id);
}

//------------------------------------------------------------------------------------------------------------
Core::FunctionReplyObject ObjectPresentation::changeStatus(const PresentationChangeStatusRequest &request)
{
  if (!isValid())
    return Core::FunctionReplyObject(m_data.id(), tr_lts("dds", "Trying to update an already removed Presentation object"));

  m_data.fileStatus(request.fileStatus());
  m_data.operatorId(request.operatorId());
  m_data.lastModified(request.lastModified());
  Database::PrePresentation dbData(toDbData(m_data));
  if (!m_mainHandler->db()->update(dbData))
    return Core::FunctionReplyObject(m_data.id(), tr_lts("dds", "Error updating Presentation-data into database"));
  // Publish Data via DTS
  onPublishData();

  return Core::FunctionReplyObject(m_data.id());
}

//------------------------------------------------------------------------------------------------------------
void ObjectPresentation::onPublishData()
{
  INFO_LOG() << "Publish Presentation-data to dds (" << m_data.id() << ") ...";

  m_mainHandler->dds()->dts()->publish(m_data);
}

// -------------------------------------------------------------------------------------------------------
// convert methods
// -------------------------------------------------------------------------------------------------------

// PresentationManagement::Presentation => Database::PrePresentation
Database::PrePresentation ObjectPresentation::toDbData(const Presentation &ddsData)
{
  Database::PrePresentation dbData;

  dbData.id = ddsData.id();
  dbData.name = QString::fromStdString(ddsData.name());
  dbData.description  = QString::fromStdString(ddsData.description());
  dbData.lastModified = ddsData.lastModified();
  dbData.operatorId   = ddsData.operatorId();
  dbData.fileStatusId = ddsData.fileStatus();

  return dbData;
}

// -------------------------------------------------------------------------------------------------------
// Database::PrePresentation => PresentationManagement::Presentation
Presentation ObjectPresentation::toDdsData(const Database::PrePresentation &dbData)
{
  Presentation ddsData;

  ddsData.id(dbData.id);
  ddsData.name(dbData.name.toStdString());
  ddsData.description(dbData.description.toStdString());
  ddsData.operatorId(dbData.operatorId);
  ddsData.lastModified(dbData.lastModified);
  ddsData.fileStatus(dbData.fileStatusId);

  // init data not in db
  ddsData.isDeleted(false);
  ddsData.isUsed(false);

  return ddsData;
}

Database::PrePresentationContent ObjectPresentation::toDbData(const PresentationContent &ddsData)
{
  Database::PrePresentationContent dbData;
  dbData.id             = ddsData.id();
  dbData.presentationId = ddsData.presentationId();
  dbData.presentationTopicType = QString::fromStdString(ddsData.presentationTopicType());
  dbData.channel        = QString::fromStdString(ddsData.channel());
  dbData.description    = QString::fromStdString(ddsData.description());
  dbData.duration       = ddsData.duration();
  dbData.startTime      = ddsData.startTime();
  dbData.attributes     = QString::fromStdString(ddsData.attributes());
  dbData.x              = ddsData.x();
  dbData.y              = ddsData.y();
  dbData.width          = ddsData.width();
  dbData.height         = ddsData.height();
  dbData.index          = ddsData.index();

  return dbData;
}

PresentationContent ObjectPresentation::toDdsData(const Database::PrePresentationContent &dbData)
{
  PresentationContent ddsData;
  ddsData.id(dbData.id);
  ddsData.presentationId(dbData.presentationId);
  ddsData.presentationTopicType(dbData.presentationTopicType.toStdString());
  ddsData.channel(dbData.channel.toStdString());
  ddsData.description(dbData.description.toStdString());
  ddsData.startTime(dbData.startTime);
  ddsData.attributes(dbData.attributes.toStdString());
  ddsData.duration(dbData.duration);
  ddsData.x(dbData.x);
  ddsData.y(dbData.y);
  ddsData.width(dbData.width);
  ddsData.height(dbData.height);
  ddsData.index(dbData.index);

  return ddsData;
}

} // namespace PresentationManagement