122 lines
4.9 KiB
C++
122 lines
4.9 KiB
C++
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
*
|
|
* Copyright (C) 2013 - 2024, nymea GmbH
|
|
* Copyright (C) 2024 - 2025, chargebyte austria GmbH
|
|
*
|
|
* This file is part of nymea-energy-plugin-nymea.
|
|
*
|
|
* nymea-energy-plugin-nymea.s free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* nymea-energy-plugin-nymea.s distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with nymea-energy-plugin-nymea. If not, see <https://www.gnu.org/licenses/>.
|
|
*
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
|
|
|
#include "flexibleload.h"
|
|
|
|
QString loadTypeToString(LoadType type)
|
|
{
|
|
switch (type) {
|
|
case LoadType::Inflexible: return QStringLiteral("Inflexible");
|
|
case LoadType::Shiftable: return QStringLiteral("Shiftable");
|
|
case LoadType::Modulable: return QStringLiteral("Modulable");
|
|
case LoadType::Storage: return QStringLiteral("Storage");
|
|
}
|
|
return QStringLiteral("Inflexible");
|
|
}
|
|
|
|
LoadType loadTypeFromString(const QString &str)
|
|
{
|
|
if (str == QLatin1String("Shiftable")) return LoadType::Shiftable;
|
|
if (str == QLatin1String("Modulable")) return LoadType::Modulable;
|
|
if (str == QLatin1String("Storage")) return LoadType::Storage;
|
|
return LoadType::Inflexible;
|
|
}
|
|
|
|
QString loadSourceToString(LoadSource source)
|
|
{
|
|
switch (source) {
|
|
case LoadSource::SmartCharging: return QStringLiteral("SmartCharging");
|
|
case LoadSource::HeatPump: return QStringLiteral("HeatPump");
|
|
case LoadSource::DHW: return QStringLiteral("DHW");
|
|
case LoadSource::Battery: return QStringLiteral("Battery");
|
|
case LoadSource::FeedIn: return QStringLiteral("FeedIn");
|
|
case LoadSource::External: return QStringLiteral("External");
|
|
}
|
|
return QStringLiteral("External");
|
|
}
|
|
|
|
LoadSource loadSourceFromString(const QString &str)
|
|
{
|
|
if (str == QLatin1String("SmartCharging")) return LoadSource::SmartCharging;
|
|
if (str == QLatin1String("HeatPump")) return LoadSource::HeatPump;
|
|
if (str == QLatin1String("DHW")) return LoadSource::DHW;
|
|
if (str == QLatin1String("Battery")) return LoadSource::Battery;
|
|
if (str == QLatin1String("FeedIn")) return LoadSource::FeedIn;
|
|
return LoadSource::External;
|
|
}
|
|
|
|
QVariantMap FlexibleLoad::toJson() const
|
|
{
|
|
QVariantMap map;
|
|
map.insert("thingId", thingId.toString());
|
|
map.insert("displayName", displayName);
|
|
map.insert("type", loadTypeToString(type));
|
|
map.insert("source", loadSourceToString(source));
|
|
map.insert("minPowerW", minPowerW);
|
|
map.insert("maxPowerW", maxPowerW);
|
|
map.insert("currentPowerW", currentPowerW);
|
|
if (deadline.isValid())
|
|
map.insert("deadline", deadline.toUTC().toString(Qt::ISODateWithMs));
|
|
map.insert("targetValue", targetValue);
|
|
map.insert("currentValue", currentValue);
|
|
map.insert("priority", priority);
|
|
map.insert("manualOverride", manualOverride);
|
|
if (!overrideReason.isEmpty())
|
|
map.insert("overrideReason", overrideReason);
|
|
return map;
|
|
}
|
|
|
|
FlexibleLoad FlexibleLoad::fromJson(const QVariantMap &map)
|
|
{
|
|
FlexibleLoad load;
|
|
load.thingId = ThingId(map.value("thingId").toString());
|
|
load.displayName = map.value("displayName").toString();
|
|
load.type = loadTypeFromString(map.value("type").toString());
|
|
load.source = loadSourceFromString(map.value("source").toString());
|
|
load.minPowerW = map.value("minPowerW").toDouble();
|
|
load.maxPowerW = map.value("maxPowerW").toDouble();
|
|
load.currentPowerW = map.value("currentPowerW").toDouble();
|
|
if (map.contains("deadline"))
|
|
load.deadline = QDateTime::fromString(map.value("deadline").toString(), Qt::ISODateWithMs).toUTC();
|
|
load.targetValue = map.value("targetValue").toDouble();
|
|
load.currentValue = map.value("currentValue").toDouble();
|
|
load.priority = map.value("priority").toDouble();
|
|
load.manualOverride= map.value("manualOverride").toBool();
|
|
load.overrideReason= map.value("overrideReason").toString();
|
|
return load;
|
|
}
|
|
|
|
QDebug operator<<(QDebug debug, const FlexibleLoad &load)
|
|
{
|
|
const QDebugStateSaver saver(debug);
|
|
debug.nospace() << "FlexibleLoad("
|
|
<< load.displayName
|
|
<< ", " << loadTypeToString(load.type)
|
|
<< ", " << loadSourceToString(load.source)
|
|
<< ", " << load.currentPowerW << "W"
|
|
<< ", priority=" << load.priority
|
|
<< ")";
|
|
return debug;
|
|
}
|