qt-migration-legatus/qt5-before/dlbo/Lts/Services/OperatorManagement/object_group.cpp

/**
  * Handler for the HMI language
  * $Id$
  * $HeadURL$
  * $Author$
  */

#include "object_group.h"

#include "main_handler.h"
#include <ngldb/dbtransaction.h>
#include "logger.h"

namespace OperatorManagement
{

ObjectGroup::ObjectGroup(MainHandler *mainHandler)
  : m_mainHandler(mainHandler)
  , m_logger(getLogger("ObjectGroup"))
{
}

ObjectGroup::~ObjectGroup()
{
  m_mainHandler->dds()->dts()->removeGroupByKey(m_data.id);
}

Core::FunctionReplyObject ObjectGroup::createObject(const Database::OpmGroup &data,
                                                    const std::vector<qint32> &isMemberOf,
                                                    const std::vector<qint32> &aclAllow,
                                                    const std::vector<qint32> &aclDeny)
{
  m_data       = data;
  m_isMemberOf = isMemberOf;
  m_aclAllow   = aclAllow;
  m_aclDeny    = aclDeny;

  if(m_data.id <= 0)
  {
    // Todo: m_mainHandler->db()->startTransaction();
    DBTransaction transaction(m_mainHandler->db()->database());

    if(!m_mainHandler->db()->insert(m_data))
    {
      return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting group into database."));
    }

    for(qint32 isMemberOfGroupId : isMemberOf)
    {
      Database::OpmGroupGroup gg;
      gg.groupId = m_data.id;
      gg.isMemberOfGroupId = isMemberOfGroupId;

      if (!m_mainHandler->db()->insert(gg))
      {
        return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting group membership into database."));
      }
    }
    for(qint32 aclId : aclAllow)
    {
      Database::OpmAclAllow allow;
      allow.groupId = m_data.id;
      allow.aclId   = aclId;

      if (!m_mainHandler->db()->insert(allow))
      {
        return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting ACL allowance data into database."));
      }
    }
    for(qint32 aclId : aclDeny)
    {
      Database::OpmAclDeny deny;
      deny.groupId = m_data.id;
      deny.aclId   = aclId;

      if (!m_mainHandler->db()->insert(deny))
      {
        return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting ACL denial data into database."));
      }
    }
    transaction.commit();
  }

  // Publish Data via DTS
  onPublishData();

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

Core::FunctionReplyObject ObjectGroup::updateObject(const Database::OpmGroup &data)
{
  if(!m_mainHandler->db()->update(data))
    return Core::FunctionReplyObject(0, tr_lts("dds", "Error updating group in database."));
  m_data = data;

  // Publish Data via DTS
  onPublishData();

  return Core::FunctionReplyObject(m_data.id);

}

Core::FunctionReplyObject ObjectGroup::updateMemberships(const std::vector<qint32> &isMemberOf)
{
  DBTransaction transaction(m_mainHandler->db()->database());
  if (!m_mainHandler->db()->removeOpmGroupGroupByGroupId(m_data.id))
    return Core::FunctionReplyObject(0, tr_lts("dds", "Error removing all group memberships."));

  for(qint32 isMemberOfGroupId : isMemberOf)
  {
    Database::OpmGroupGroup gg;
    gg.groupId = m_data.id;
    gg.isMemberOfGroupId = isMemberOfGroupId;
    if (!m_mainHandler->db()->insert(gg))
    {
      return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting group membership into database."));
    }
  }
  transaction.commit();

  m_isMemberOf = isMemberOf;
  // Publish Data via DTS
  onPublishData();

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

Core::FunctionReplyObject ObjectGroup::updateAcls(const std::vector<qint32> &aclAllow, const std::vector<qint32> &aclDeny)
{
  DBTransaction transaction(m_mainHandler->db()->database());
  if (!m_mainHandler->db()->removeOpmAclAllowByGroupId(m_data.id))
    return Core::FunctionReplyObject(0, tr_lts("dds", "Error removing all group memberships."));

  for(qint32 aclId : aclAllow)
  {
    Database::OpmAclAllow allow;
    allow.groupId = m_data.id;
    allow.aclId   = aclId;

    if (!m_mainHandler->db()->insert(allow))
      return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting ACL allowance data into database."));
  }
  if (!m_mainHandler->db()->removeOpmAclDenyByGroupId(m_data.id))
    return Core::FunctionReplyObject(0, tr_lts("dds", "Error removing all group memberships."));

  for(qint32 aclId : aclDeny)
  {
    Database::OpmAclDeny deny;
    deny.groupId = m_data.id;
    deny.aclId   = aclId;

    if (!m_mainHandler->db()->insert(deny))
      return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting ACL denial data into database."));
  }
  transaction.commit();

  m_aclAllow   = aclAllow;
  m_aclDeny    = aclDeny;

  // Publish Data via DTS
  onPublishData();

  return Core::FunctionReplyObject(m_data.id);

}

Core::FunctionReplyObject ObjectGroup::removeObject()
{
  // on Delete Cascade?
//  removeAllAclAllows();
//  removeAllAclDenys();


  //  removeAllMemberships();

  if (!m_mainHandler->db()->removeOpmGroup(m_data.id))
    return Core::FunctionReplyObject(m_data.id, tr_lts("dds", "Group with id %1 can not be removed.")).arg(m_data.id);

  if (!m_mainHandler->dts()->removeGroupByKey(m_data.id))
    return Core::FunctionReplyObject(m_data.id, tr_lts("dds", "Group with id %1 can not be taken from DDS.")).arg(m_data.id);

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

Core::FunctionReplyObject ObjectGroup::removeAllMemberships()
{
  if (!m_mainHandler->db()->removeOpmGroupGroupByGroupId(m_data.id))
    return Core::FunctionReplyObject(0, tr_lts("dds", "Error removing all group memberships."));

  // Todo: Really?
  if (!m_mainHandler->db()->removeOpmGroupGroupByIsMemberOfGroupId(m_data.id))
    return Core::FunctionReplyObject(0, tr_lts("dds", "Error removing group out of other groups."));

  m_isMemberOf.clear();

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

Core::FunctionReplyObject ObjectGroup::removeAllAclAllows()
{
  if (!m_mainHandler->db()->removeOpmAclAllowByGroupId(m_data.id))
    return Core::FunctionReplyObject(0, tr_lts("dds", "Error removing all ACL allowances data."));

  m_aclAllow.clear();

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

Core::FunctionReplyObject ObjectGroup::removeAllAclDenys()
{
  if (!m_mainHandler->db()->removeOpmAclDenyByGroupId(m_data.id))
    return Core::FunctionReplyObject(0, tr_lts("dds", "Error removing all ACL denies data."));

  m_aclDeny.clear();

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

void ObjectGroup::onPublishData()
{
  OperatorManagement::Group ddsData;

  ddsData.id(m_data.id);
  ddsData.name(m_data.name.toStdString());
  ddsData.description(m_data.description.toStdString());
  ddsData.aclAllow(m_aclAllow);
  ddsData.aclDeny(m_aclDeny);
  ddsData.isHidden(m_data.isHidden);
  ddsData.type(m_data.typeId);
  ddsData.isMemberOf(m_isMemberOf);

  INFO_LOG(m_logger) << "Publish OpmGroup-data to dds (" << m_data.id << ") ...";

  if (!m_mainHandler->dts()->publish(ddsData))
  {
    ERROR_LOG(m_logger) << "Error publishing OpmGroup-data to dds";
  }
}

} // Namespace OperatorManagement