4 files changed, 60 insertions(+), 62 deletions(-)

M module-db/Database/Field.cpp
M module-db/Database/Field.hpp
M module-db/Database/sqlite3vfs.cpp
M module-services/service-db/agents/settings/FactorySettings.cpp

@@ 1,4 1,4 @@
-// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2023, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include "Field.hpp"


@@ 10,6 10,11 @@ const char *Field::getCString() const
     return mValue.c_str();
 }
 
+const std::string &Field::getString() const
+{
+    return mValue;
+}
+
 template <class T>
 static T lget(T &val, const std::string &mValue, std::function<T()> foo)
 {


@@ 44,47 49,47 @@ double Field::getDouble() const
     return lget<double>(ret, mValue, [=]() -> double { return std::stod(mValue); });
 }
 
-int8_t Field::getInt8() const
+std::int8_t Field::getInt8() const
 {
-    return !mValue.empty() ? static_cast<int8_t>(atol(mValue.c_str())) : int8_t(0);
+    return !mValue.empty() ? static_cast<std::int8_t>(atol(mValue.c_str())) : static_cast<std::int8_t>(0);
 }
 
-int32_t Field::getInt32() const
+std::int32_t Field::getInt32() const
 {
-    return !mValue.empty() ? static_cast<int32_t>(atol(mValue.c_str())) : int32_t(0);
+    return !mValue.empty() ? static_cast<std::int32_t>(atol(mValue.c_str())) : static_cast<std::int32_t>(0);
 }
 
-uint8_t Field::getUInt8() const
+std::uint8_t Field::getUInt8() const
 {
-    return !mValue.empty() ? static_cast<uint8_t>(atol(mValue.c_str())) : uint8_t(0);
+    return !mValue.empty() ? static_cast<std::uint8_t>(atol(mValue.c_str())) : static_cast<std::uint8_t>(0);
 }
 
-uint16_t Field::getUInt16() const
+std::uint16_t Field::getUInt16() const
 {
-    return !mValue.empty() ? static_cast<uint16_t>(atol(mValue.c_str())) : uint16_t(0);
+    return !mValue.empty() ? static_cast<std::uint16_t>(atol(mValue.c_str())) : static_cast<std::uint16_t>(0);
 }
 
-int16_t Field::getInt16() const
+std::int16_t Field::getInt16() const
 {
-    return !mValue.empty() ? static_cast<int16_t>(atol(mValue.c_str())) : int16_t(0);
+    return !mValue.empty() ? static_cast<std::int16_t>(atol(mValue.c_str())) : static_cast<std::int16_t>(0);
 }
 
-uint32_t Field::getUInt32() const
+std::uint32_t Field::getUInt32() const
 {
-    uint32_t ret;
-    return lget<uint32_t>(ret, mValue, [=]() -> unsigned long { return std::stoul(mValue); });
+    std::uint32_t ret;
+    return lget<std::uint32_t>(ret, mValue, [=]() -> unsigned long { return std::stoul(mValue); });
 }
 
-uint64_t Field::getUInt64() const
+std::uint64_t Field::getUInt64() const
 {
-    uint64_t ret;
-    return lget<uint64_t>(ret, mValue, [=]() -> unsigned long long { return std::stoull(mValue); });
+    std::uint64_t ret;
+    return lget<std::uint64_t>(ret, mValue, [=]() -> unsigned long long { return std::stoull(mValue); });
 }
 
-int64_t Field::getInt64() const
+std::int64_t Field::getInt64() const
 {
-    int64_t ret;
-    return lget<int64_t>(ret, mValue, [=]() -> long long { return std::stoll(mValue); });
+    std::int64_t ret;
+    return lget<std::int64_t>(ret, mValue, [=]() -> long long { return std::stoll(mValue); });
 }
 
 void Field::setValue(const char *value)

@@ 1,4 1,4 @@
-// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2023, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #pragma once


@@ 14,33 14,27 @@ class Field
 
     Field(const char *value)
     {
-        if (value) {
+        if (value != nullptr) {
             mValue = value;
         }
     }
-    // Field(Field const&);
-
-    // Field& operator=(Field const&);
 
     ~Field()
     {}
 
     const char *getCString() const;
-    std::string getString() const
-    {
-        return mValue;
-    }
+    const std::string &getString() const;
     float getFloat() const;
     bool getBool() const;
     double getDouble() const;
-    int8_t getInt8() const;
-    int32_t getInt32() const;
-    uint8_t getUInt8() const;
-    uint16_t getUInt16() const;
-    int16_t getInt16() const;
-    uint32_t getUInt32() const;
-    uint64_t getUInt64() const;
-    int64_t getInt64() const;
+    std::int8_t getInt8() const;
+    std::int32_t getInt32() const;
+    std::uint8_t getUInt8() const;
+    std::uint16_t getUInt16() const;
+    std::int16_t getInt16() const;
+    std::uint32_t getUInt32() const;
+    std::uint64_t getUInt64() const;
+    std::int64_t getInt64() const;
     void setValue(const char *value);
 
   private:

@@ 113,9 113,7 @@
 #include <assert.h>
 #include <string.h>
 #include <sys/types.h>
-#include <sys/param.h>
 #include <unistd.h>
-#include <time.h>
 #include <errno.h>
 #include <memory>
 #include <cstring>

@@ 11,8 11,8 @@ namespace settings
 
     std::unique_ptr<QueryResult> FactorySettings::getMfgEntries()
     {
-        auto factoryContent                      = readMfgSettings(filePath);
-        std::unique_ptr<QueryResult> factoryData = std::make_unique<QueryResult>();
+        auto factoryData          = std::make_unique<QueryResult>();
+        const auto factoryContent = readMfgSettings(filePath);
 
         for (const auto &[path, value] : factoryContent.object_items()) {
             factoryData->addRow({Field(path.c_str()), Field(value.string_value().c_str())});


@@ 23,32 23,33 @@ namespace settings
 
     void FactorySettings::initDb(Database *database)
     {
-        auto factoryData = getMfgEntries();
-        if (factoryData->getRowCount()) {
-            do {
-
-                settings::EntryPath variablePath{"",
-                                                 "",
-                                                 "",
-                                                 settings::factory::entry_key + std::string("/") +
-                                                     (*factoryData)[0].getString(),
-                                                 settings::SettingsScope::Global};
-                auto value = (*factoryData)[1].getString();
-
-                if (!database->execute(
-                        settings::Statements::insertValue, variablePath.to_string().c_str(), value.c_str())) {
-                    break;
-                }
-
-                LOG_INFO("Put factory entry: %s=%s", variablePath.to_string().c_str(), value.c_str());
-
-            } while (factoryData->nextRow());
+        const auto factoryData = getMfgEntries();
+
+        if (factoryData->getRowCount() <= 0) {
+            LOG_FATAL("No EEPROM factory data available!");
+            return;
         }
+
+        do {
+            const auto key        = (*factoryData)[0].getString();
+            const auto value      = (*factoryData)[1].getCString();
+            const auto path       = settings::factory::entry_key + std::string("/") + key;
+            const auto pathString = settings::EntryPath{"", "", "", path, settings::SettingsScope::Global}.to_string();
+
+            if (!database->execute(settings::Statements::insertValue, pathString.c_str(), value)) {
+                LOG_ERROR("Failed to set entry '%s' = '%s'!", pathString.c_str(), value);
+            }
+            else {
+                LOG_INFO("Set entry '%s' = '%s'", pathString.c_str(), value);
+            }
+
+        } while (factoryData->nextRow());
     }
+
     json11::Json FactorySettings::readMfgSettings(const std::string &path)
     {
         std::ifstream file(path.c_str());
-        std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
+        const std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
 
         std::string parserError;
         auto factoryObj = json11::Json::parse(content, parserError);