Adds initial intermediate qt6 porting state

qt6-after/qt6-migrated-legatus/Lts/Plugins/AppStarter/Gui/AppStart/CMakeLists.txt

@@ -0,0 +1,27 @@
+#
+# $Id$
+# $HeadURL$
+# $Author$
+#
+# Created by Mike Wille, SLSE, 2016-11-03
+#
+
+SET(AppStarterGuiPlugin_SRCS
+  app_gui_plugin.h
+  app_gui_plugin.cpp
+)
+
+NGL_ADD_LIBRARY(WS AppStarterGuiPlugin MODULE ${AppStarterGuiPlugin_SRCS})
+NGL_TARGET_LINK_LIBRARIES(AppStarterGuiPlugin
+  LtsSession
+  AppGuiPluginInterface
+  LtsAppManager
+  LtsAppDescriptor
+  Qt5::Widgets
+  LtsWidgets
+  LtsSessionData
+  LtsUtilsSettings
+  svcIsmCommon # for DbAdmin right
+)
+
+NGL_INSTALL_TARGET(AppStarterGuiPlugin)

qt6-after/qt6-migrated-legatus/Lts/Plugins/AppStarter/Gui/AppStart/app_gui_plugin.cpp

@@ -0,0 +1,390 @@
+
+
+
+#include "app_gui_plugin.h"
+
+#include <LtsSession/lts_session.h>
+#include <LtsWidgets/lts_message_dialog.h>
+#include <LtsAppManager/lts_app_manager.h>
+#include <LtsAppDescriptor/lts_app_descriptor.h>
+#include <LtsWidgets/lts_global_wait_dialog.h>
+#include <NGLLogger/NGLLoggerBootstrap.h>
+#include <LtsSession/lts_session_data.h>
+#include <LtsUtilsSettings/settings.h>
+#include <Services/InfrastructureManagement/ism_operator_rights.h>
+
+#include <QApplication>
+
+namespace AppStarter
+{
+
+std::shared_ptr<GuiPluginBase::Interface> GuiPlugin::createGuiInterface(LtsSession::LtsSession *session)
+{
+  return std::make_shared<InterfaceImpl>(session);
+}
+
+
+InterfaceImpl::InterfaceImpl(LtsSession::LtsSession *session)
+  : GuiPluginBase::Interface(session, NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("AppStarter")) 
+{}
+
+static inline LtsAppDescriptor::AppDescriptionVector getAvailableApps(LtsAppDescriptor::App curAppId)
+{
+  LtsAppDescriptor::AppDescriptionVector apps = LtsAppManager::LtsAppManager::getInstance()->getAvailableApps();
+  if (curAppId == LtsAppDescriptor::App::OC)
+  {
+    
+    apps.erase(std::remove_if(apps.begin(), apps.end(),
+                              [](const LtsAppDescriptor::AppDescription & app)
+    {
+      switch (app.id)
+      {
+      case LtsAppDescriptor::App::OnlineHelp:
+      case LtsAppDescriptor::App::Snapshot:
+      case LtsAppDescriptor::App::BuildingViewer:
+      case LtsAppDescriptor::App::Login:
+      case LtsAppDescriptor::App::OC:           
+        return false;
+      default:
+        return true;
+      }
+    }), apps.end());
+
+    if( strcmp(PROJECTBUILD, "guez") == 0)
+    {
+      apps.erase(std::remove_if(apps.begin(), apps.end(),
+                                [](const LtsAppDescriptor::AppDescription & app)
+      {
+        switch (app.id)
+        {
+        case LtsAppDescriptor::App::OnlineHelp:
+          return true;
+        default:
+          return false;
+        }
+      }), apps.end());
+    }
+  }
+  else if (LtsSessionData::LtsSessionData::getInstance()->isTablet())
+  {
+    apps.erase(std::remove_if(apps.begin(), apps.end(),
+                              [](const LtsAppDescriptor::AppDescription & app)
+    {
+      switch (app.id)
+      {
+
+      if (strcmp(PROJECTBUILD, "commaster") == 0)
+      {
+      case LtsAppDescriptor::App::Situation:
+      case LtsAppDescriptor::App::Scripts:
+      case LtsAppDescriptor::App::ScriptEditorEssentialsView:
+      case LtsAppDescriptor::App::SymbolEditor:
+      case LtsAppDescriptor::App::PlanEditor:
+          return false;
+      }
+
+      if (strcmp(PROJECTBUILD, "demotablet") == 0)
+      {
+      case LtsAppDescriptor::App::BuildingViewer:
+          return false;
+      }
+
+      case LtsAppDescriptor::App::OnlineHelp:
+      case LtsAppDescriptor::App::Snapshot:
+      case LtsAppDescriptor::App::Login:
+      case LtsAppDescriptor::App::OC:           
+        return false;
+      default:
+        return true;
+      }
+    }), apps.end());
+
+
+    if( strcmp(PROJECTBUILD, "guez") == 0)
+    {
+      apps.erase(std::remove_if(apps.begin(), apps.end(),
+                                [](const LtsAppDescriptor::AppDescription & app)
+      {
+        switch (app.id)
+        {
+        case LtsAppDescriptor::App::OnlineHelp:
+          return true;
+        default:
+          return false;
+        }
+      }), apps.end());
+    }
+
+  }
+  else
+  {
+    
+    apps.erase(std::remove_if(apps.begin(), apps.end(),
+                              [](const LtsAppDescriptor::AppDescription & app)
+    {
+      return app.id == LtsAppDescriptor::App::OC;
+    }), apps.end());
+  }
+
+  
+  
+  
+
+  return apps;
+}
+
+QVector<LtsWidgets::PluginData> InterfaceImpl::getActions()
+{
+  QVector<LtsWidgets::PluginData> ret;
+
+  const LtsSessionData::LtsSessionData *sessionData = LtsSessionData::LtsSessionData::getInstance();
+  const LtsAppDescriptor::AppDescriptionVector &apps = getAvailableApps(appId());
+
+  for (const LtsAppDescriptor::AppDescription &app : apps)
+  {
+    
+    if (app.id == LtsAppDescriptor::App::OC)
+      continue;
+
+    
+    const QSet<int> &acls = sessionData->getOperatorRights();
+    bool hasRight = true; 
+    for (int reqRight : app.requiredAcls)
+    {
+      if (!acls.contains(reqRight))
+        hasRight = false;
+    }
+
+    if (!hasRight)
+      continue;
+
+    if (!app.visible) 
+      continue;
+
+    LtsWidgets::PluginData plData;
+    plData.menuGroup  = menuGroup();
+    plData.menuText   = LtsSession::LtsSession::appToString(app.id);
+    plData.menuIcon   = LtsSession::LtsSession::appToIcon(app.id);
+    plData.identifier = QStringLiteral("app%1").arg(int(app.id));
+    plData.directFunc = [this, app](const LtsWidgets::PluginData &)
+    {
+      return startApp(app.id);
+    };
+
+    ret.append(plData);
+  }
+
+
+#ifdef Q_OS_UNIX
+  {
+    LtsWidgets::PluginData plData;
+    plData.menuGroup        = menuGroup();
+    plData.menuText         = tr("Take Screenshot");
+    plData.identifier       = QLatin1String("TakeScreenshot");
+    plData.menuIcon         = QIcon(QLatin1String("icon:create_snapshot.svg"));
+    
+    plData.directFunc = [this](const LtsWidgets::PluginData & plData)
+    {
+      const QString appPath(QLatin1String("mate-screenshot"));
+      const QStringList args(QStringLiteral("-i"));
+
+      startProcess(appPath, args, plData.menuText, plData.identifier);
+
+    };
+    ret.append(plData);
+  }
+#endif
+
+
+  LtsUtils::ProjectSettings *ps = LtsUtils::ProjectSettings::getInstance();
+  const bool enableDatabaseAdministrationTools = ps->value(QStringLiteral("dat"),
+                                                           QStringLiteral("enableDatabaseAdministrationTools")).toBool();
+
+  if (enableDatabaseAdministrationTools && m_session->app() != LtsAppDescriptor::App::ResourceManager)
+  {
+#ifndef TABLET_MODE
+    if (m_session->partitionType() == IDL::PartitionType::Global)
+    {
+      {
+        LtsWidgets::PluginData plData;
+        plData.menuGroup        = tr("Database Administration Tools");
+        plData.menuText         = tr("Database Administration");
+        plData.identifier       = QLatin1String("StartDbAdministration");
+        plData.menuIcon         = QIcon(QLatin1String("icon:plans.svg"));
+        plData.operatorRight    = OperatorRights::DatabaseAdministration;
+        plData.directFunc = [this](const LtsWidgets::PluginData & plData)
+        {
+#ifdef Q_OS_UNIX
+          
+          const QStringList args({QStringLiteral("-p"), QStringLiteral("ctc11de"),
+                                  QStringLiteral("ssh"), QStringLiteral("ctc_sv@excadb01"),
+                                  QStringLiteral("-X"),
+                                  
+                                  QStringLiteral("-o"), QStringLiteral("StrictHostKeyChecking=no"),
+                                  QStringLiteral("dbAdministration")
+                                 });
+          const QString appPath(QLatin1String("sshpass"));
+#else
+          const QStringList args;
+          
+          const QString appPath(QCoreApplication::applicationDirPath() + QLatin1Char('/') + QLatin1String("dbAdministration"));
+#endif
+          startProcess(appPath, args, plData.menuText, plData.identifier);
+        };
+        ret.append(plData);
+      }
+
+
+      LtsWidgets::PluginData plData;
+      plData.menuGroup        = tr("Database Administration Tools");
+      plData.menuText         = tr("TeamPostgreSQL");
+      plData.identifier       = QLatin1String("TeamPostgresql");
+      plData.menuIcon         = QIcon(QLatin1String("icon:plans.svg"));
+      plData.operatorRight    = OperatorRights::DatabaseAdministration;
+      plData.directFunc = [this](const LtsWidgets::PluginData & plData)
+      {
+        const QStringList args({QLatin1String("excadb01:8082/teampostgresql/")});
+        startProcess(QLatin1String("firefox"), args, plData.menuText, plData.identifier);
+      };
+      ret.append(plData);
+    }
+#endif
+  }
+  return ret;
+}
+
+void InterfaceImpl::startProcess(const QString &procName, const QStringList &args, const QString &title, const QString &identifier)
+{
+  DEBUG_LOG(m_logger) << LOGFUNCTION << " START";
+
+  
+  if (identifier.isEmpty())
+    return;
+
+  QPointer<QProcess> proc = m_ProcMap.value(identifier);
+  if (proc)
+  {
+    DEBUG_LOG(m_logger) << "kill QProcess: "
+                        << " pid=" << proc->processId()
+                        << " state=" << proc->state();
+    if (proc->processId() > 0) 
+    {
+      proc->kill();
+      if (!proc->waitForFinished())
+      {
+        DEBUG_LOG(m_logger) << "!proc->waitForFinished()";
+        return;
+      }
+    }
+  }
+  else
+  {
+    
+
+    DEBUG_LOG(m_logger) << "new QProcess";
+    proc = new QProcess(this);
+    m_ProcMap.insert(identifier, proc);
+
+    DEBUG_LOG(m_logger) << "Starting process '" << procName << "' with args '" << args.join(QLatin1Char(' ')) << "'";
+
+    
+    
+
+    connect(proc.data(), &QProcess::readyReadStandardError,
+            this, [this, proc, title]()
+    {
+      DEBUG_LOG(m_logger) << "QProcess::readyReadStandardError";
+      const QString readStdErr = QString::fromLocal8Bit(proc->readAllStandardError());
+      if (readStdErr.contains(QLatin1String("swrast", Qt::CaseInsensitive)))
+        return;
+      WARNING_LOG(m_logger) << QStringLiteral("readAllStandardError: %1 while running process %2 with args %3")
+                               .arg(readStdErr, proc->program(), proc->arguments().join(QLatin1Char(' ')));
+      
+      if (readStdErr.contains(QLatin1String("ERROR", Qt::CaseInsensitive)))
+        new LtsWidgets::LtsMessageDialogNew(m_session->baseLayout(),
+                                            tr("Error: \"%1\"\nwhile running process %2 with args %3").arg(readStdErr, proc->program(), proc->arguments().join(QLatin1Char(' '))),
+                                            title);
+    });
+
+    connect(proc.data(), &QProcess::errorOccurred,
+            this, [this, proc, title](const QProcess::ProcessError & error)
+    {
+      ERROR_LOG(m_logger) << "QProcess::errorOccurred";
+      const QVariant done(proc->property("properlyStarted"));
+      if (!done.canConvert(QVariant::Bool) || done.toBool() == false)
+      {
+        new LtsWidgets::LtsMessageDialogNew(m_session->baseLayout(),
+                                            tr("Starting app failed - error id: %1").arg(static_cast<int>(error)),
+                                            title);
+        
+      }
+    });
+    connect(proc.data(), &QProcess::stateChanged,
+            this, [this](const QProcess::ProcessState & state)
+    {
+      DEBUG_LOG(m_logger) << "QProcess::stateChanged" << state;
+    });
+
+    connect(proc.data(), QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
+            this, [this, proc](int, QProcess::ExitStatus)
+    {
+      DEBUG_LOG(m_logger) << "QProcess::finished";
+      proc->deleteLater();
+    });
+
+    proc->setProgram(procName);
+    proc->setArguments(args);
+    proc->start();
+
+    if (!proc->waitForStarted())
+    {
+      ERROR_LOG(m_logger) << "Could not start process '" << procName << "' with args '" << args.join(QLatin1Char(' ')) << "'";
+      proc->deleteLater();
+    }
+    proc->setProperty("properlyStarted", true);
+    
+  }
+  DEBUG_LOG(m_logger) << LOGFUNCTION << " END";
+}
+
+void InterfaceImpl::startApp(LtsAppDescriptor::App appId)
+{
+  LtsSession::DdsConnectionParams hackParams(m_session->connParams());
+
+  
+  
+  {
+    
+    hackParams.exerciseId = 0; 
+    hackParams.partitionId = 0; 
+    hackParams.partitionType = IDL::PartitionType::Global;
+  }
+  
+  
+  
+  const LtsSessionData::LtsSessionData *sessionData = LtsSessionData::LtsSessionData::getInstance();
+  hackParams.tcpConnectionUrl = sessionData->getTcpConnectionUrl();
+  if (sessionData->getDomainIdPreset() > 0)
+    hackParams.domainId = sessionData->getDomainIdPreset();
+
+  const LtsAppDescriptor::AppDescriptionVector apps = LtsAppManager::LtsAppManager::getInstance()->getAvailableApps();
+
+  for (const LtsAppDescriptor::AppDescription &app : apps)
+  {
+    if (app.id == appId)
+    {
+      LtsAppManager::LtsAppManager::getInstance()->createApp(app.id, hackParams);
+      return;
+    }
+  }
+
+  LtsWidgets::LtsMessageDialog::showMessage(m_session->baseLayoutWidget(), tr("Invalid app"));
+}
+
+
+QString InterfaceImpl::menuGroup() const
+{
+  return tr("Apps");
+}
+
+} 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AppStarter/Gui/AppStart/app_gui_plugin.h

@@ -0,0 +1,49 @@
+
+
+
+#pragma once
+
+#include <Plugins/AppStarter/app_gui_plugin_interface.h>
+#include <PluginInterfaces/gui_plugin_interface.h>
+#include <QProcess>
+
+namespace AppStarter
+{
+
+class GuiPlugin final : public QObject, public GuiPluginBase::Plugin
+{
+  Q_PLUGIN_METADATA(IID "gui:3:app")
+  Q_INTERFACES(GuiPluginBase::Plugin)
+
+  Q_OBJECT
+
+public:
+  explicit GuiPlugin() = default;
+  ~GuiPlugin() = default;
+
+  QString pluginName() override { return ForeignGuiInterface::pluginName(); }
+  std::shared_ptr<GuiPluginBase::Interface> createGuiInterface(LtsSession::LtsSession *session) override;
+  bool availableInPartition(IDL::PartitionType) const override
+  {
+    return true;
+  }
+};
+
+
+class InterfaceImpl final : public QObject, public GuiPluginBase::Interface
+{
+  Q_OBJECT
+
+public:
+  explicit InterfaceImpl(LtsSession::LtsSession *session);
+
+  QVector<LtsWidgets::PluginData> getActions() override;
+  QString menuGroup() const override;
+
+private:
+  void startProcess(const QString &procName, const QStringList &args, const QString &title, const QString &identifier);
+  void startApp(LtsAppDescriptor::App appId);
+  QMap< QString, QPointer<QProcess> > m_ProcMap;
+};
+
+}