suyu
/
suyu_two
1
0
Vork 0
Code Kwesties 0 Pull-aanvragen 0 Publicaties 0 Wiki Activiteit
综合平台编程器项目的远程存储
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
116 Commits
1 Branch
183 MiB
 
 
 
 
Tree: 6594ef1183
Branches Labels
${ item.name }
Maak branch ${ searchTerm }
van '6594ef1183'
${ noResults }
suyu_two/app/src/infrastructure/application_settings_loader...

510 regels
17 KiB
Ruw Blame Geschiedenis 

  1. #include "application_settings_loader.h"

  2. 

  3. #include "domain/project_limits.h"

  4. 

  5. #include <QCoreApplication>

  6. #include <QDir>

  7. #include <QFile>

  8. #include <QFileInfo>

  9. #include <QMap>

  10. #include <QSaveFile>

  11. #include <QSet>

  12. #include <QStringList>

  13. #include <QTextCodec>

  14. 

  15. #include <initializer_list>

  16. 

  17. namespace {

  18. 

  19. constexpr int kCurrentConfigurationVersion = 1;

  20. 

  21. struct ParsedEntry

  22. {

  23.     QString value;

  24.     int line = 0;

  25. };

  26. 

  27. std::string toUtf8(const QString &value)

  28. {

  29.     const QByteArray bytes = value.toUtf8();

  30.     return std::string(bytes.constData(), static_cast<std::size_t>(bytes.size()));

  31. }

  32. 

  33. QString defaultFileContents()

  34. {

  35.     return QStringLiteral(

  36.         "[Config]\n"

  37.         "Version=1\n"

  38.         "\n"

  39.         "[ProjectLimits]\n"

  40.         "MaxHmiPages=32\n"

  41.         "MaxHmiControlsPerPage=128\n"

  42.         "MaxAlarmDefinitions=256\n"

  43.         "MaxControlLogics=32\n"

  44.         "MaxRungsPerLogic=256\n"

  45.         "MaxOutputMessages=1000\n"

  46.         "\n"

  47.         "[HmiDefaults]\n"

  48.         "DefaultPageWidth=800\n"

  49.         "DefaultPageHeight=400\n"

  50.         "\n"

  51.         "[PlcDefaults]\n"

  52.         "PortName=COM3\n"

  53.         "ServerAddress=1\n"

  54.         "BaudRate=9600\n"

  55.         "DataBits=8\n"

  56.         "Parity=2\n"

  57.         "StopBits=1\n");

  58. }

  59. 

  60. ApplicationSettingsLoadResult failureResult(

  61.     const QString &file_path, const QString &reason)

  62. {

  63.     ApplicationSettingsLoadResult result;

  64.     result.warningRequired = true;

  65.     result.warningMessage = toUtf8(

  66.         QStringLiteral("应用配置无法使用，本次已全部采用代码默认值。\n%1")

  67.             .arg(reason));

  68.     result.messages.push_back(toUtf8(

  69.         QStringLiteral("应用配置错误：%1（%2）")

  70.             .arg(reason, QDir::toNativeSeparators(file_path))));

  71.     result.messages.push_back(

  72.         "应用配置：本次运行全部使用代码默认值");

  73.     return result;

  74. }

  75. 

  76. bool containsValue(std::initializer_list<int> values, int value)

  77. {

  78.     for (int candidate : values)

  79.     {

  80.         if (candidate == value)

  81.         {

  82.             return true;

  83.         }

  84.     }

  85.     return false;

  86. }

  87. 

  88. bool readInteger(

  89.     const QMap<QString, ParsedEntry> &entries,

  90.     const QString &path,

  91.     qint64 minimum,

  92.     qint64 maximum,

  93.     qint64 default_value,

  94.     qint64 *value,

  95.     QStringList *notices,

  96.     QStringList *errors,

  97.     bool required = false)

  98. {

  99.     const auto entry = entries.constFind(path);

  100.     if (entry == entries.cend())

  101.     {

  102.         if (required)

  103.         {

  104.             errors->append(QStringLiteral("缺少必填字段 %1").arg(path));

  105.         }

  106.         else

  107.         {

  108.             notices->append(

  109.                 QStringLiteral("配置字段 %1 缺失，使用代码默认值 %2")

  110.                     .arg(path)

  111.                     .arg(default_value));

  112.         }

  113.         *value = default_value;

  114.         return !required;

  115.     }

  116. 

  117.     bool converted = false;

  118.     const qint64 parsed = entry->value.toLongLong(&converted, 10);

  119.     if (!converted || parsed < minimum || parsed > maximum)

  120.     {

  121.         errors->append(

  122.             QStringLiteral("第 %1 行字段 %2 的值“%3”无效，允许范围为 %4~%5")

  123.                 .arg(entry->line)

  124.                 .arg(path, entry->value)

  125.                 .arg(minimum)

  126.                 .arg(maximum));

  127.         return false;

  128.     }

  129.     *value = parsed;

  130.     return true;

  131. }

  132. 

  133. void addUnsupportedValueError(

  134.     const QMap<QString, ParsedEntry> &entries,

  135.     const QString &path,

  136.     const QString &allowed,

  137.     QStringList *errors)

  138. {

  139.     const ParsedEntry &entry = entries[path];

  140.     errors->append(

  141.         QStringLiteral("第 %1 行字段 %2 的值“%3”无效，只允许 %4")

  142.             .arg(entry.line)

  143.             .arg(path, entry.value, allowed));

  144. }

  145. 

  146. } // namespace

  147. 

  148. QString ApplicationSettingsLoader::defaultFilePath()

  149. {

  150.     return QDir(QCoreApplication::applicationDirPath()).filePath(

  151.         QStringLiteral("config/application.ini"));

  152. }

  153. 

  154. ApplicationSettingsLoadResult ApplicationSettingsLoader::load(

  155.     const QString &file_path)

  156. {

  157.     if (!QFileInfo::exists(file_path))

  158.     {

  159.         const QString directory = QFileInfo(file_path).absolutePath();

  160.         if (!QDir().mkpath(directory))

  161.         {

  162.             return failureResult(

  163.                 file_path,

  164.                 QStringLiteral("无法创建配置目录 %1，可能没有写入权限")

  165.                     .arg(QDir::toNativeSeparators(directory)));

  166.         }

  167. 

  168.         QSaveFile file(file_path);

  169.         if (!file.open(QIODevice::WriteOnly))

  170.         {

  171.             return failureResult(file_path, file.errorString());

  172.         }

  173.         const QByteArray data = defaultFileContents().toUtf8();

  174.         if (file.write(data) != data.size())

  175.         {

  176.             const QString reason = file.errorString();

  177.             file.cancelWriting();

  178.             return failureResult(file_path, reason);

  179.         }

  180.         if (!file.commit())

  181.         {

  182.             return failureResult(file_path, file.errorString());

  183.         }

  184. 

  185.         ApplicationSettingsLoadResult result;

  186.         result.messages.push_back(toUtf8(

  187.             QStringLiteral("应用配置：已创建默认配置文件 %1")

  188.                 .arg(QDir::toNativeSeparators(file_path))));

  189.         result.messages.push_back(

  190.             "应用配置：首次运行使用代码默认值，修改后请重启程序");

  191.         return result;

  192.     }

  193. 

  194.     QFile file(file_path);

  195.     if (!file.open(QIODevice::ReadOnly))

  196.     {

  197.         return failureResult(file_path, file.errorString());

  198.     }

  199.     const QByteArray data = file.readAll();

  200.     if (file.error() != QFileDevice::NoError)

  201.     {

  202.         return failureResult(file_path, file.errorString());

  203.     }

  204. 

  205.     QTextCodec::ConverterState converter_state;

  206.     const QString text = QTextCodec::codecForName("UTF-8")->toUnicode(

  207.         data.constData(), data.size(), &converter_state);

  208.     if (converter_state.invalidChars > 0)

  209.     {

  210.         return failureResult(file_path, QStringLiteral("配置文件不是有效的 UTF-8 文本"));

  211.     }

  212. 

  213.     const QSet<QString> known_fields{

  214.         QStringLiteral("Config.Version"),

  215.         QStringLiteral("ProjectLimits.MaxHmiPages"),

  216.         QStringLiteral("ProjectLimits.MaxHmiControlsPerPage"),

  217.         QStringLiteral("ProjectLimits.MaxAlarmDefinitions"),

  218.         QStringLiteral("ProjectLimits.MaxControlLogics"),

  219.         QStringLiteral("ProjectLimits.MaxRungsPerLogic"),

  220.         QStringLiteral("ProjectLimits.MaxOutputMessages"),

  221.         QStringLiteral("HmiDefaults.DefaultPageWidth"),

  222.         QStringLiteral("HmiDefaults.DefaultPageHeight"),

  223.         QStringLiteral("PlcDefaults.PortName"),

  224.         QStringLiteral("PlcDefaults.ServerAddress"),

  225.         QStringLiteral("PlcDefaults.BaudRate"),

  226.         QStringLiteral("PlcDefaults.DataBits"),

  227.         QStringLiteral("PlcDefaults.Parity"),

  228.         QStringLiteral("PlcDefaults.StopBits")};

  229. 

  230.     QMap<QString, ParsedEntry> entries;

  231.     QStringList notices;

  232.     QStringList errors;

  233.     QString current_section;

  234.     QString normalized_text = text;

  235.     if (!normalized_text.isEmpty()

  236.         && normalized_text.front() == QChar::ByteOrderMark)

  237.     {

  238.         normalized_text.remove(0, 1);

  239.     }

  240.     const QStringList lines = normalized_text.split(QLatin1Char('\n'));

  241.     for (int index = 0; index < lines.size(); ++index)

  242.     {

  243.         QString line = lines.at(index);

  244.         if (line.endsWith(QLatin1Char('\r')))

  245.         {

  246.             line.chop(1);

  247.         }

  248.         const QString trimmed = line.trimmed();

  249.         const int line_number = index + 1;

  250.         if (trimmed.isEmpty() || trimmed.startsWith(QLatin1Char(';'))

  251.             || trimmed.startsWith(QLatin1Char('#')))

  252.         {

  253.             continue;

  254.         }

  255.         if (trimmed.startsWith(QLatin1Char('[')))

  256.         {

  257.             if (!trimmed.endsWith(QLatin1Char(']')) || trimmed.size() < 3)

  258.             {

  259.                 errors.append(

  260.                     QStringLiteral("第 %1 行分区格式无效：%2")

  261.                         .arg(line_number)

  262.                         .arg(trimmed));

  263.                 current_section.clear();

  264.                 continue;

  265.             }

  266.             current_section = trimmed.mid(1, trimmed.size() - 2).trimmed();

  267.             if (current_section.isEmpty())

  268.             {

  269.                 errors.append(QStringLiteral("第 %1 行分区名称不能为空").arg(line_number));

  270.             }

  271.             continue;

  272.         }

  273. 

  274.         const int separator = trimmed.indexOf(QLatin1Char('='));

  275.         if (separator <= 0 || current_section.isEmpty())

  276.         {

  277.             errors.append(

  278.                 QStringLiteral("第 %1 行字段格式无效：%2")

  279.                     .arg(line_number)

  280.                     .arg(trimmed));

  281.             continue;

  282.         }

  283.         const QString key = trimmed.left(separator).trimmed();

  284.         const QString value = trimmed.mid(separator + 1).trimmed();

  285.         if (key.isEmpty())

  286.         {

  287.             errors.append(QStringLiteral("第 %1 行字段名称不能为空").arg(line_number));

  288.             continue;

  289.         }

  290.         const QString path = current_section + QLatin1Char('.') + key;

  291.         if (entries.contains(path))

  292.         {

  293.             errors.append(

  294.                 QStringLiteral("第 %1 行字段 %2 重复，首次出现在第 %3 行")

  295.                     .arg(line_number)

  296.                     .arg(path)

  297.                     .arg(entries.value(path).line));

  298.             continue;

  299.         }

  300.         entries.insert(path, {value, line_number});

  301.         if (!known_fields.contains(path))

  302.         {

  303.             notices.append(

  304.                 QStringLiteral("第 %1 行未知字段 %2 已忽略")

  305.                     .arg(line_number)

  306.                     .arg(path));

  307.         }

  308.     }

  309. 

  310.     ApplicationSettings candidate;

  311.     qint64 parsed = 0;

  312.     if (readInteger(

  313.             entries, QStringLiteral("Config.Version"),

  314.             kCurrentConfigurationVersion, kCurrentConfigurationVersion,

  315.             kCurrentConfigurationVersion, &parsed, &notices, &errors, true))

  316.     {

  317.         candidate.version = static_cast<int>(parsed);

  318.     }

  319. 

  320.     if (readInteger(

  321.             entries, QStringLiteral("ProjectLimits.MaxHmiPages"),

  322.             1, ProjectLimits::kMaximumHmiPages,

  323.             ProjectLimits::kMaximumHmiPages, &parsed, &notices, &errors))

  324.     {

  325.         candidate.projectLimits.maximumHmiPages = static_cast<std::size_t>(parsed);

  326.     }

  327.     if (readInteger(

  328.             entries, QStringLiteral("ProjectLimits.MaxHmiControlsPerPage"),

  329.             1, ProjectLimits::kMaximumHmiControlsPerPage,

  330.             ProjectLimits::kMaximumHmiControlsPerPage,

  331.             &parsed, &notices, &errors))

  332.     {

  333.         candidate.projectLimits.maximumHmiControlsPerPage =

  334.             static_cast<std::size_t>(parsed);

  335.     }

  336.     if (readInteger(

  337.             entries, QStringLiteral("ProjectLimits.MaxAlarmDefinitions"),

  338.             0, ProjectLimits::kMaximumAlarmDefinitions,

  339.             ProjectLimits::kMaximumAlarmDefinitions,

  340.             &parsed, &notices, &errors))

  341.     {

  342.         candidate.projectLimits.maximumAlarmDefinitions =

  343.             static_cast<std::size_t>(parsed);

  344.     }

  345.     if (readInteger(

  346.             entries, QStringLiteral("ProjectLimits.MaxControlLogics"),

  347.             1, ProjectLimits::kMaximumControlLogics,

  348.             ProjectLimits::kMaximumControlLogics,

  349.             &parsed, &notices, &errors))

  350.     {

  351.         candidate.projectLimits.maximumControlLogics =

  352.             static_cast<std::size_t>(parsed);

  353.     }

  354.     if (readInteger(

  355.             entries, QStringLiteral("ProjectLimits.MaxRungsPerLogic"),

  356.             0, ProjectLimits::kMaximumRungsPerLogic,

  357.             ProjectLimits::kMaximumRungsPerLogic,

  358.             &parsed, &notices, &errors))

  359.     {

  360.         candidate.projectLimits.maximumRungsPerLogic =

  361.             static_cast<std::size_t>(parsed);

  362.     }

  363.     if (readInteger(

  364.             entries, QStringLiteral("ProjectLimits.MaxOutputMessages"),

  365.             1, ProjectLimits::kMaximumOutputMessages,

  366.             ProjectLimits::kMaximumOutputMessages,

  367.             &parsed, &notices, &errors))

  368.     {

  369.         candidate.projectLimits.maximumOutputMessages = static_cast<int>(parsed);

  370.     }

  371. 

  372.     if (readInteger(

  373.             entries, QStringLiteral("HmiDefaults.DefaultPageWidth"),

  374.             ProjectLimits::kMinimumHmiPageWidth,

  375.             ProjectLimits::kMaximumHmiPageWidth,

  376.             ProjectLimits::kDefaultHmiPageWidth,

  377.             &parsed, &notices, &errors))

  378.     {

  379.         candidate.hmiDefaults.pageWidth = static_cast<int>(parsed);

  380.     }

  381.     if (readInteger(

  382.             entries, QStringLiteral("HmiDefaults.DefaultPageHeight"),

  383.             ProjectLimits::kMinimumHmiPageHeight,

  384.             ProjectLimits::kMaximumHmiPageHeight,

  385.             ProjectLimits::kDefaultHmiPageHeight,

  386.             &parsed, &notices, &errors))

  387.     {

  388.         candidate.hmiDefaults.pageHeight = static_cast<int>(parsed);

  389.     }

  390. 

  391.     const QString port_path = QStringLiteral("PlcDefaults.PortName");

  392.     const auto port_entry = entries.constFind(port_path);

  393.     if (port_entry == entries.cend())

  394.     {

  395.         notices.append(

  396.             QStringLiteral("配置字段 %1 缺失，使用代码默认值 COM3")

  397.                 .arg(port_path));

  398.     }

  399.     else

  400.     {

  401.         const QByteArray port_bytes = port_entry->value.toUtf8();

  402.         if (port_entry->value.trimmed().isEmpty()

  403.             || port_bytes.size() > static_cast<int>(ProjectLimits::kMaximumIdBytes))

  404.         {

  405.             errors.append(

  406.                 QStringLiteral("第 %1 行字段 %2 的值“%3”无效，端口名称不能为空且不能超过 128 个 UTF-8 字节")

  407.                     .arg(port_entry->line)

  408.                     .arg(port_path, port_entry->value));

  409.         }

  410.         else

  411.         {

  412.             candidate.plcDefaults.portName = toUtf8(port_entry->value.trimmed());

  413.         }

  414.     }

  415. 

  416.     if (readInteger(

  417.             entries, QStringLiteral("PlcDefaults.ServerAddress"),

  418.             ProjectLimits::kMinimumPlcServerAddress,

  419.             ProjectLimits::kMaximumPlcServerAddress,

  420.             candidate.plcDefaults.serverAddress,

  421.             &parsed, &notices, &errors))

  422.     {

  423.         candidate.plcDefaults.serverAddress = static_cast<int>(parsed);

  424.     }

  425. 

  426.     int baud_rate = candidate.plcDefaults.baudRate;

  427.     if (readInteger(

  428.             entries, QStringLiteral("PlcDefaults.BaudRate"),

  429.             9600, 115200, candidate.plcDefaults.baudRate,

  430.             &parsed, &notices, &errors))

  431.     {

  432.         baud_rate = static_cast<int>(parsed);

  433.         if (!containsValue({9600, 19200, 38400, 57600, 115200}, baud_rate))

  434.         {

  435.             addUnsupportedValueError(

  436.                 entries, QStringLiteral("PlcDefaults.BaudRate"),

  437.                 QStringLiteral("9600、19200、38400、57600 或 115200"), &errors);

  438.         }

  439.         else

  440.         {

  441.             candidate.plcDefaults.baudRate = baud_rate;

  442.         }

  443.     }

  444. 

  445.     if (readInteger(

  446.             entries, QStringLiteral("PlcDefaults.DataBits"),

  447.             7, 8, candidate.plcDefaults.dataBits,

  448.             &parsed, &notices, &errors))

  449.     {

  450.         candidate.plcDefaults.dataBits = static_cast<int>(parsed);

  451.     }

  452. 

  453.     int parity = candidate.plcDefaults.parity;

  454.     if (readInteger(

  455.             entries, QStringLiteral("PlcDefaults.Parity"),

  456.             0, 3, candidate.plcDefaults.parity,

  457.             &parsed, &notices, &errors))

  458.     {

  459.         parity = static_cast<int>(parsed);

  460.         if (!containsValue({0, 2, 3}, parity))

  461.         {

  462.             addUnsupportedValueError(

  463.                 entries, QStringLiteral("PlcDefaults.Parity"),

  464.                 QStringLiteral("0、2 或 3"), &errors);

  465.         }

  466.         else

  467.         {

  468.             candidate.plcDefaults.parity = parity;

  469.         }

  470.     }

  471. 

  472.     if (readInteger(

  473.             entries, QStringLiteral("PlcDefaults.StopBits"),

  474.             1, 2, candidate.plcDefaults.stopBits,

  475.             &parsed, &notices, &errors))

  476.     {

  477.         candidate.plcDefaults.stopBits = static_cast<int>(parsed);

  478.     }

  479. 

  480.     if (!errors.isEmpty())

  481.     {

  482.         ApplicationSettingsLoadResult result;

  483.         result.warningRequired = true;

  484.         result.warningMessage =

  485.             "应用配置存在严重错误，本次已全部采用代码默认值。详细原因请查看底部输出面板。";

  486.         for (const QString &error : errors)

  487.         {

  488.             result.messages.push_back(toUtf8(QStringLiteral("应用配置错误：") + error));

  489.         }

  490.         for (const QString &notice : notices)

  491.         {

  492.             result.messages.push_back(toUtf8(QStringLiteral("应用配置提示：") + notice));

  493.         }

  494.         result.messages.push_back(

  495.             "应用配置：整份配置不生效，本次运行全部使用代码默认值");

  496.         return result;

  497.     }

  498. 

  499.     ApplicationSettingsLoadResult result;

  500.     result.settings = candidate;

  501.     result.messages.push_back(toUtf8(

  502.         QStringLiteral("应用配置：已加载 %1，修改后需重启程序")

  503.             .arg(QDir::toNativeSeparators(file_path))));

  504.     for (const QString &notice : notices)

  505.     {

  506.         result.messages.push_back(toUtf8(QStringLiteral("应用配置提示：") + notice));

  507.     }

  508.     return result;

  509. }