qt-migration-legatus/qt6-after/qt6-migrated-legatus/Z/src/nglsettings/nglsettings_settings.cpp

#include "nglsettings_settings.h"
#include "nglsettings_connections.h"

#include <ngltools/ngltools_filesystem.h>

#include <QtCore/QCoreApplication>
#include <QtCore/QDir>
#include <QtCore/QSettings>
#include <QtCore/QSize>
#include <QtCore/QStandardPaths>

namespace NGL
{
  QSettings *Settings::s_globalSettings = nullptr;

  Settings::Settings(const QString &iniFile_)
      : m_settings(nullptr)
  {
    QString iniFile = iniFile_;
    if (iniFile == QLatin1String("gfs_ws.ini"))
    {
      const QByteArray defUser = qgetenv("USER");
      if (defUser == "ctc_aar" || defUser == "ctc_rbf")
      {
        QByteArray home = qgetenv("HOME");
        if (!home.isEmpty())
        {
          QString fn = QString::fromLocal8Bit(home) + QLatin1String("/gfs_") + QString::fromLocal8Bit(defUser.mid(4)) + QLatin1String(".ini");
          QFileInfo fi(fn);
          if (fi.exists() && fi.isFile() && fi.isReadable())
          {
            iniFile = fn;
          }
        }
      }
    }

    initializeGlobalSettings();

    initPre();
    if (!iniFile.isEmpty())
    {
      if (QFileInfo(iniFile).isAbsolute())
        m_settings = new QSettings(iniFile, QSettings::IniFormat);
      else
        m_settings = new QSettings(basePath() + iniFile, QSettings::IniFormat);
      initPost();
    }

    if (!m_settings)
      m_settings = new QSettings(QLatin1String("RDE"));
  }

  Settings::Settings(const QString &organization, const QString &application)
      : m_settings(new QSettings(organization, application))
  {
    initPre();
    initPost();
  }

  Settings::~Settings()
  {
    delete m_settings;
  }

  void Settings::initializeGlobalSettings()
  {
    if (s_globalSettings)
      return;

    if (!s_globalSettings)
    {
      QString globalSettingsFile = NGL::findProjectConfigFile();


      if (!globalSettingsFile.isEmpty())
        s_globalSettings = new QSettings(globalSettingsFile, QSettings::IniFormat);
    }
    if (!s_globalSettings)
      s_globalSettings = new QSettings(QLatin1String("RDE"), QLatin1String("LTS-CC"));
    Connections::setPortOffset(portOffset());
    Connections::setServerHostname(serverHostname());
  }

  QString Settings::globalSectionName()
  {
    QString secName = QLatin1String("Global");
    static const char envGlobSecName[] = "LTS_CONF_GLOBAL_SECTION_NAME";
    if (qEnvironmentVariableIsSet(envGlobSecName))
      secName = QString::fromLocal8Bit(qgetenv(envGlobSecName));

    return secName;
  }

  QString Settings::basePath() const
  {
    return m_paths["GFS_PATH"];
  }

  QString Settings::tempPath() const
  {
    return m_paths["TMP_PATH"];
  }

  QString Settings::printPath()
  {
    return getDirectory("PDF", tempPath());
  }

  QString Settings::logoProject()
  {
    return QLatin1String(":project/logo.png");
  }

  QString Settings::bitmapPath()
  {
    return getDirectory("BITMAPS", basePath() + QLatin1String("DATA"));
  }

  QString Settings::zsks_rxPath()
  {
    return getDirectory("ZSKS_RX", tempPath());
  }

  QString Settings::zsks_txPath()
  {
    return getDirectory("ZSKS_TX", tempPath());
  }

  QString Settings::aarServerPath(int exerciseId)
  {
    return getDirectory(QByteArray::number(exerciseId), QString::fromLocal8Bit("/data/aar/"));
  }

  bool Settings::isDatabaseConnectionLocal()
  {
    return (databaseHostname() == QStringLiteral("localhost"));
  }

  QString Settings::databaseName()
  {
    initializeGlobalSettings();

    return s_globalSettings->value(globalSectionName() + QLatin1String("/DatabaseName"), QLatin1String("lts_ets_pro")).toString();
  }

  QString Settings::databaseHostname()
  {
    initializeGlobalSettings();
    return s_globalSettings->value(QLatin1String("Global/DatabaseHostname"), QLatin1String("EXCDBS01")).toString();
  }

  QString Settings::databaseUser()
  {
#ifdef Q_OS_WIN
    QByteArray defUser = qgetenv("USERNAME");
#else
    QByteArray defUser = qgetenv("USER");
#endif
    QString ret = m_settings->value(QLatin1String("db/user"), QString::fromLocal8Bit(defUser)).toString();
    return ret;
  }

  QString Settings::databasePassword(const QString &databaseUser)
  {
    QString defaultPw = QStringLiteral("ctc11de");
    if (!databaseUser.isEmpty())
    {
      const QStringList sl = databaseUser.split(QLatin1Char('_'));
      if (!sl.isEmpty())
        defaultPw = sl.at(0) + QStringLiteral("11de");
    }
    return m_settings->value(QLatin1String("db/passwd"), defaultPw).toString();
  }

  QString Settings::databaseDriver()
  {
    return m_settings->value(QLatin1String("db/driver"), QLatin1String("QPSQL")).toString();
  }

  int Settings::avsKeepAliveTimeout()
  {
    return m_settings->value(QLatin1String("avs/keepalivetimeout"), 20000).toInt();
  }

  QString Settings::avsServerHost()
  {
    return m_settings->value(QLatin1String("avs/serverhost"), QLatin1String("EXCAVS01")).toString();
  }

  quint16 Settings::avsServerPortAVE()
  {
    static const quint16 defaultPort = 6350;
    bool bOk;
    quint16 ret = m_settings->value(QLatin1String("avs/serverport_ave"), defaultPort).toUInt(&bOk);
    return bOk ? ret : defaultPort;
  }

  QSettings *Settings::settings()
  {
    return m_settings;
  }

  const QSettings *Settings::settings() const
  {
    return m_settings;
  }

  QString Settings::fixupPath(const QString &_path) const
  {
    QString path = QDir::fromNativeSeparators(_path);
    if (!QDir::isAbsolutePath(path))
      path = basePath() + path;
    path = QDir::cleanPath(path);
    if (!path.endsWith(QLatin1Char('/')))
      path += QLatin1Char('/');
    return path;
  }

  QString Settings::getDirectory(const QByteArray &_dir, const QString &defPrefix, bool bPathLowercase)
  {
    if (m_paths[_dir].isEmpty())
    {
      const QString lowerDir = QString::fromLatin1(_dir.toLower());
      const QString dir = bPathLowercase ? lowerDir : QString::fromLatin1(_dir);
      QString def = defPrefix + QLatin1Char('/') + dir + QLatin1Char('/');
      m_paths[_dir] = fixupPath(m_settings->value(QLatin1String("paths/") + lowerDir, def).toString());
      QDir d(m_paths[_dir]);
      if (!d.exists())
        d.mkpath(d.absolutePath());
    }
    return m_paths[_dir];
  }

  void Settings::initPre()
  {
#ifdef WIN32
    QString path = QString::fromLocal8Bit(qgetenv("GFS_PATH"));
    if (path.isEmpty())
      path = QCoreApplication::applicationDirPath();
    m_paths["GFS_PATH"] = fixupPath(path);
#else
    QByteArray path = qgetenv("GFS_PATH");
    if (path.isEmpty())
      path = qgetenv("HOME");
    m_paths["GFS_PATH"] = fixupPath(QString::fromLocal8Bit(path));
#endif

    QByteArray tmppath = qgetenv("TMP_PATH");
    if (tmppath.isEmpty())
      tmppath = qgetenv("TMP");
    if (tmppath.isEmpty())
      tmppath = QDir::tempPath().toLocal8Bit();
    m_paths["TMP_PATH"] = fixupPath(QString::fromLocal8Bit(tmppath));
  }

  void Settings::initPost()
  {
    NGL::Connections::setIniFile(m_settings->fileName());
  }

  int Settings::getInteger(const QString &key, int defVal) const
  {
    bool bOk;
    int ret = m_settings->value(key, defVal).toInt(&bOk);
    return bOk ? ret : defVal;
  }

  float Settings::getFloat(const QString &key, float defVal) const
  {
    bool bOk;
    float ret = m_settings->value(key, defVal).toFloat(&bOk);
    return bOk ? ret : defVal;
  }

  double Settings::getDouble(const QString &key, double defVal) const
  {
    bool bOk;
    double ret = m_settings->value(key, defVal).toDouble(&bOk);
    return bOk ? ret : defVal;
  }

  bool Settings::getBoolean(const QString &key, bool defVal) const
  {
    return m_settings->value(key, defVal).toBool();
  }

  QString Settings::getString(const QString &key, const QString &defVal) const
  {
    return m_settings->value(key, defVal).toString();
  }

  unsigned short Settings::domainId()
  {
    initializeGlobalSettings();
    return s_globalSettings->value(QLatin1String("Global/DomainId"), 0).toUInt();
  }

  unsigned short Settings::portOffset()
  {
    initializeGlobalSettings();
    return s_globalSettings->value(QLatin1String("Global/PortOffset"), 9000).toUInt();
  }

  QString Settings::serverHostname()
  {
    initializeGlobalSettings();
    return s_globalSettings->value(QLatin1String("Global/ServerHostname"), QLatin1String("EXCTDS01")).toString();
  }

  QString Settings::logPath()
  {
    initializeGlobalSettings();
#ifdef WIN32
    return s_globalSettings->value(QLatin1String("Global/LogPath"), QStandardPaths::writableLocation(QStandardPaths::TempLocation)).toString();
#else
    return s_globalSettings->value(QLatin1String("Global/LogPath"), QLatin1String("/shd/CTC/LOG")).toString();
#endif
  }

}