refactor: refactor the application to the mvvm architecture (#2009)

* refactor: move business logic from servers model

* refactor: move containersModel initialization

* refactor: added protocol ui controller and removed settings class from protocols model

* refactor: moved cli management to separate controller

* refactor: moved app split to separate controller

* refactor: moved site split to separate controller

* refactor: moved allowed dns to separate controller

* refactor: moved language logic to separate ui controller

* refactor: removed Settings from devices model

* refactor: moved configs and services api logit to separate core controller

* refactor: added a layer with a repository between the storage and controllers

* refactor: use child parent system instead of smart pointers for controllers and models initialization

* refactor: moved install functions from server controller to install controller

* refactor: install controller refactoring

* chore: renamed exportController to exportUiController

* refactor: separate export controller

* refactor: removed VpnConfigurationsController

* chore: renamed ServerController to SshSession

* refactor: replaced ServerController to SshSession

* chore: moved qml controllers to separate folder

* chore: include fixes

* chore: moved utils from core root to core/utils

* chore: include fixes

* chore: rename core/utils files to camelCase foramt

* chore: include fixes

* chore: moved some utils to api and selfhosted folders

* chore: include fixes

* chore: remove unused file

* chore: moved serialization folder to core/utils

* chore: include fixes

* chore: moved some files from client root to core/utils

* chore: include fixes

* chore: moved ui utils to ui/utils folder

* chore: include fixes

* chore: move utils from root to ui/utils

* chore: include fixes

* chore: moved configurators to core/configurators

* chore: include fixes

* refactor: moved iap logic from ui controller to core

* refactor: moved remaining core logic from ApiConfigsController to SubscriptionController

* chore: rename apiNewsController to apiNewsUiController

* refactor: moved core logic from news ui controller to core

* chore: renamed apiConfigsController to subscriptionUiController

* chore: include fixes

* refactor: merge ApiSettingsController with SubscriptionUiController

* chore: moved ui selfhosted controllers to separate folder

* chore: include fixes

* chore: rename connectionController to connectiomUiController

* refactor: moved core logic from connectionUiController

* chore: rename settingsController to settingsUiController

* refactor: move core logic from settingsUiController

* refactor: moved core controller signal/slot connections to separate class

* fix: newsController fixes after refactoring

* chore: rename model to camelCase

* chore: include fixes

* chore: remove unused code

* chore: move selfhosted core to separate folder

* chore: include fixes

* chore: rename importController to importUiController

* refactor: move core logic from importUiController

* chore: minor fixes

* chore: remove prem v1 migration

* refactor: remove openvpn over cloak and openvpn over shadowsocks

* refactor: removed protocolsForContainer function

* refactor: add core models

* refactor: replace json with c++ structs for server config

* refactor: move getDnsPair to ServerConfigUtils

* feat: add admin selfhosted config export test

* feat: add multi import test

* refactor: use coreController for tests

* feat: add few simple tests

* chore: qrepos in all core controllers

* feat: add test for settings

* refactor: remove repo dependency from configurators

* chore: moved protocols to core folder

* chore: include fixes

* refactor: moved containersDefs, defs, apiDefs, protocolsDefs to different places

* chore: include fixes

* chore: build fixes

* chore: build fixes

* refactor: remove q repo and interface repo

* feat: add test for ui servers model and controller

* chore: renamed to camelCase

* chore: include fixes

* refactor: moved core logic from sites ui controller

* fix: fixed api config processing

* fix: fixed processed server index processing

* refactor: protocol models now use c++ structs instead of json configs

* refactor: servers model now use c++ struct instead of json config

* fix: fixed default server index processing

* fix: fix logs init

* fix: fix secure settings load keys

* chore: build fixes

* fix: fixed clear settings

* fix: fixed restore backup

* fix: sshSession usage

* fix: fixed export functions signatures

* fix: return missing part from buildContainerWorker

* fix: fixed server description on page home

* refactor: add container config helpers functions

* refactor: c++ structs instead of json

* chore: add dns protocol config struct

* refactor: move config utils functions to config structs

* feat: add test for selfhosted server setup

* refactor: separate resources.qrc

* fix: fixed server rename

* chore: return nameOverriddenByUser

* fix: build fixes

* fix: fixed models init

* refactor: cleanup models usage

* fix: fixed models init

* chore: cleanup connections and functions signatures

* chore: cleanup updateModel calls

* feat: added cache to servers repo

* chore: cleanup unused functions

* chore: ssxray processing

* chore: remove transportProtoWithDefault and portWithDefault functions

* chore: removed proto types any and l2tp

* refactor: moved some constants

* fix: fixed native configs export

* refactor: remove json from processConfigWith functions

* fix: fixed processed server index usage

* fix: qml warning fixes

* chore: merge fixes

* chore: update tests

* fix: fixed xray config processing

* fix: fixed split tunneling processing

* chore: rename sites controllers and model

* chore: rename fixes

* chore: minor fixes

* chore: remove ability to load backup from "file with connection settings" button

* fix: fixed api device revoke

* fix: remove full model update when renaming a user

* fix: fixed premium/free server rename

* fix: fixed selfhosted new server install

* fix: fixed updateContainer function

* fix: fixed revoke for external premium configs

* feat: add native configs qr processing

* chore: codestyle fixes

* fix: fixed admin config create

* chore: again remove ability to load backup from "file with connection settings" button

* chore: minor fixes

* fix: fixed variables initialization

* fix: fixed qml imports

* fix: minor fixes

* fix: fix vpnConnection function calls

* feat: add buckup error handling

* fix: fixed admin config revok

* fix: fixed selfhosted awg installation

* fix: ad visability

* feat: add empty check for primary dns

* chore: minor fixes
This commit is contained in:
vkamn
2026-04-30 14:53:03 +08:00
committed by GitHub
parent 2edd7de413
commit 847bb6923b
469 changed files with 25992 additions and 17154 deletions
+223
View File
@@ -0,0 +1,223 @@
#include "apiConfig.h"
#include <QJsonDocument>
#include <QDateTime>
#include "core/utils/api/apiUtils.h"
#include "core/utils/constants/apiKeys.h"
namespace amnezia
{
QJsonObject ApiConfig::Subscription::toJson() const
{
QJsonObject obj;
if (!endDate.isEmpty()) {
obj[apiDefs::key::endDate] = endDate;
}
return obj;
}
ApiConfig::Subscription ApiConfig::Subscription::fromJson(const QJsonObject& json)
{
Subscription sub;
sub.endDate = json.value(apiDefs::key::endDate).toString();
return sub;
}
QJsonObject ApiConfig::ServiceInfo::toJson() const
{
QJsonObject obj;
obj[apiDefs::key::isAdVisible] = isAdVisible;
obj[apiDefs::key::isRenewalAvailable] = isRenewalAvailable;
if (!adHeader.isEmpty()) {
obj[apiDefs::key::adHeader] = adHeader;
}
if (!adDescription.isEmpty()) {
obj[apiDefs::key::adDescription] = adDescription;
}
if (!adEndpoint.isEmpty()) {
obj[apiDefs::key::adEndpoint] = adEndpoint;
}
return obj;
}
ApiConfig::ServiceInfo ApiConfig::ServiceInfo::fromJson(const QJsonObject& json)
{
ServiceInfo info;
info.isAdVisible = json.value(apiDefs::key::isAdVisible).toBool(false);
info.isRenewalAvailable = json.value(apiDefs::key::isRenewalAvailable).toBool(false);
info.adHeader = json.value(apiDefs::key::adHeader).toString();
info.adDescription = json.value(apiDefs::key::adDescription).toString();
info.adEndpoint = json.value(apiDefs::key::adEndpoint).toString();
return info;
}
QJsonObject ApiConfig::PublicKeyInfo::toJson() const
{
QJsonObject obj;
if (!expiresAt.isEmpty()) {
obj[apiDefs::key::expiresAt] = expiresAt;
}
return obj;
}
ApiConfig::PublicKeyInfo ApiConfig::PublicKeyInfo::fromJson(const QJsonObject& json)
{
PublicKeyInfo info;
info.expiresAt = json.value(apiDefs::key::expiresAt).toString();
return info;
}
bool ApiConfig::isPremium() const
{
return serviceType == "amnezia-premium";
}
bool ApiConfig::isFree() const
{
return serviceType == "amnezia-free";
}
bool ApiConfig::isExternalPremium() const
{
return serviceType == "external-premium";
}
bool ApiConfig::isSubscriptionExpired() const
{
if (subscription.endDate.isEmpty()) {
return false;
}
QDateTime endDate = QDateTime::fromString(subscription.endDate, Qt::ISODateWithMs);
if (!endDate.isValid()) {
endDate = QDateTime::fromString(subscription.endDate, Qt::ISODate);
}
if (!endDate.isValid()) {
return false;
}
return endDate < QDateTime::currentDateTimeUtc();
}
QJsonObject ApiConfig::toJson() const
{
QJsonObject obj;
if (!serviceType.isEmpty()) {
obj[apiDefs::key::serviceType] = serviceType;
}
if (!serviceProtocol.isEmpty()) {
obj[QLatin1String("service_protocol")] = serviceProtocol;
}
if (!userCountryCode.isEmpty()) {
obj[QLatin1String("user_country_code")] = userCountryCode;
}
if (!serverCountryCode.isEmpty()) {
obj[apiDefs::key::serverCountryCode] = serverCountryCode;
}
if (!serverCountryName.isEmpty()) {
obj[apiDefs::key::serverCountryName] = serverCountryName;
}
if (!vpnKey.isEmpty()) {
obj[apiDefs::key::vpnKey] = vpnKey;
}
QJsonObject subscriptionObj = subscription.toJson();
if (!subscriptionObj.isEmpty()) {
obj[apiDefs::key::subscription] = subscriptionObj;
}
if (activeDeviceCount > 0) {
obj[apiDefs::key::activeDeviceCount] = activeDeviceCount;
}
if (maxDeviceCount > 0) {
obj[apiDefs::key::maxDeviceCount] = maxDeviceCount;
}
if (issuedConfigs > 0) {
obj[apiDefs::key::issuedConfigs] = issuedConfigs;
}
if (!availableCountries.isEmpty()) {
obj[apiDefs::key::availableCountries] = availableCountries;
}
if (!supportedProtocols.isEmpty()) {
obj[apiDefs::key::supportedProtocols] = supportedProtocols;
}
QJsonObject serviceInfoObj = serviceInfo.toJson();
if (!serviceInfoObj.isEmpty()) {
obj[apiDefs::key::serviceInfo] = serviceInfoObj;
}
QJsonObject publicKeyObj = publicKey.toJson();
if (!publicKeyObj.isEmpty()) {
obj[apiDefs::key::publicKey] = publicKeyObj;
}
if (!stackType.isEmpty()) {
obj[apiDefs::key::stackType] = stackType;
}
if (!cliVersion.isEmpty()) {
obj[apiDefs::key::cliVersion] = cliVersion;
}
if (isTestPurchase) {
obj[apiDefs::key::isTestPurchase] = isTestPurchase;
}
if (isInAppPurchase) {
obj[apiDefs::key::isInAppPurchase] = isInAppPurchase;
}
if (subscriptionExpiredByServer) {
obj[apiDefs::key::subscriptionExpiredByServer] = subscriptionExpiredByServer;
}
return obj;
}
ApiConfig ApiConfig::fromJson(const QJsonObject& json)
{
ApiConfig config;
config.serviceType = json.value(apiDefs::key::serviceType).toString();
config.serviceProtocol = json.value(QLatin1String("service_protocol")).toString();
config.userCountryCode = json.value(QLatin1String("user_country_code")).toString();
config.serverCountryCode = json.value(apiDefs::key::serverCountryCode).toString();
config.serverCountryName = json.value(apiDefs::key::serverCountryName).toString();
config.vpnKey = json.value(apiDefs::key::vpnKey).toString();
QJsonObject subscriptionObj = json.value(apiDefs::key::subscription).toObject();
if (!subscriptionObj.isEmpty()) {
config.subscription = Subscription::fromJson(subscriptionObj);
}
config.activeDeviceCount = json.value(apiDefs::key::activeDeviceCount).toInt(0);
config.maxDeviceCount = json.value(apiDefs::key::maxDeviceCount).toInt(0);
config.issuedConfigs = json.value(apiDefs::key::issuedConfigs).toInt(0);
config.availableCountries = json.value(apiDefs::key::availableCountries).toArray();
config.supportedProtocols = json.value(apiDefs::key::supportedProtocols).toArray();
QJsonObject serviceInfoObj = json.value(apiDefs::key::serviceInfo).toObject();
if (!serviceInfoObj.isEmpty()) {
config.serviceInfo = ServiceInfo::fromJson(serviceInfoObj);
}
QJsonObject publicKeyObj = json.value(apiDefs::key::publicKey).toObject();
if (!publicKeyObj.isEmpty()) {
config.publicKey = PublicKeyInfo::fromJson(publicKeyObj);
}
config.stackType = json.value(apiDefs::key::stackType).toString();
config.cliVersion = json.value(apiDefs::key::cliVersion).toString();
config.isTestPurchase = json.value(apiDefs::key::isTestPurchase).toBool(false);
config.isInAppPurchase = json.value(apiDefs::key::isInAppPurchase).toBool(false);
config.subscriptionExpiredByServer = json.value(apiDefs::key::subscriptionExpiredByServer).toBool(false);
return config;
}
} // namespace amnezia
+77
View File
@@ -0,0 +1,77 @@
#ifndef APICONFIG_H
#define APICONFIG_H
#include <QJsonObject>
#include <QJsonArray>
#include <QString>
#include <QDateTime>
#include "core/utils/api/apiEnums.h"
#include "core/utils/constants/apiKeys.h"
#include "core/utils/constants/apiConstants.h"
namespace amnezia
{
struct ApiConfig
{
QString serviceType;
QString serviceProtocol;
QString userCountryCode;
QString serverCountryCode;
QString serverCountryName;
QString vpnKey;
struct Subscription {
QString endDate;
QJsonObject toJson() const;
static Subscription fromJson(const QJsonObject& json);
};
Subscription subscription;
int activeDeviceCount;
int maxDeviceCount;
int issuedConfigs;
QJsonArray availableCountries;
QJsonArray supportedProtocols;
struct ServiceInfo {
bool isAdVisible = false;
bool isRenewalAvailable = false;
QString adHeader;
QString adDescription;
QString adEndpoint;
QJsonObject toJson() const;
static ServiceInfo fromJson(const QJsonObject& json);
};
ServiceInfo serviceInfo;
struct PublicKeyInfo {
QString expiresAt;
QJsonObject toJson() const;
static PublicKeyInfo fromJson(const QJsonObject& json);
};
PublicKeyInfo publicKey;
QString stackType;
QString cliVersion;
bool isTestPurchase;
bool isInAppPurchase = false;
bool subscriptionExpiredByServer = false;
bool isPremium() const;
bool isFree() const;
bool isExternalPremium() const;
bool isSubscriptionExpired() const;
QJsonObject toJson() const;
static ApiConfig fromJson(const QJsonObject& json);
};
} // namespace amnezia
#endif // APICONFIG_H
@@ -0,0 +1,140 @@
#include "apiV1ServerConfig.h"
#include <QJsonArray>
#include <QJsonDocument>
#include "core/utils/containerEnum.h"
#include "core/utils/containers/containerUtils.h"
#include "core/utils/protocolEnum.h"
#include "core/utils/protocolEnum.h"
#include "core/protocols/protocolUtils.h"
#include "core/utils/constants/apiKeys.h"
#include "core/utils/constants/configKeys.h"
#include "core/utils/constants/protocolConstants.h"
#include "core/utils/api/apiUtils.h"
namespace amnezia
{
using namespace ContainerEnumNS;
bool ApiV1ServerConfig::isPremium() const
{
constexpr QLatin1String premiumV1Endpoint(PREM_V1_ENDPOINT);
return apiEndpoint.contains(premiumV1Endpoint);
}
bool ApiV1ServerConfig::isFree() const
{
constexpr QLatin1String freeV2Endpoint(FREE_V2_ENDPOINT);
return apiEndpoint.contains(freeV2Endpoint);
}
QString ApiV1ServerConfig::vpnKey() const
{
QJsonObject json = toJson();
return apiUtils::getPremiumV1VpnKey(json);
}
bool ApiV1ServerConfig::hasContainers() const
{
return !containers.isEmpty();
}
ContainerConfig ApiV1ServerConfig::containerConfig(DockerContainer container) const
{
if (!containers.contains(container)) {
return ContainerConfig{};
}
return containers.value(container);
}
QJsonObject ApiV1ServerConfig::toJson() const
{
QJsonObject obj;
if (!name.isEmpty()) {
obj[configKey::name] = name;
}
if (!description.isEmpty()) {
obj[configKey::description] = description;
}
if (!protocol.isEmpty()) {
obj[apiDefs::key::protocol] = protocol;
}
if (!apiEndpoint.isEmpty()) {
obj[apiDefs::key::apiEndpoint] = apiEndpoint;
}
if (!apiKey.isEmpty()) {
obj[apiDefs::key::apiKey] = apiKey;
}
obj[configKey::configVersion] = configVersion;
if (!hostName.isEmpty()) {
obj[configKey::hostName] = hostName;
}
QJsonArray containersArray;
for (auto it = containers.begin(); it != containers.end(); ++it) {
QJsonObject containerObj = it.value().toJson();
containersArray.append(containerObj);
}
if (!containersArray.isEmpty()) {
obj[configKey::containers] = containersArray;
}
if (defaultContainer != DockerContainer::None) {
obj[configKey::defaultContainer] = ContainerUtils::containerToString(defaultContainer);
}
if (!dns1.isEmpty()) {
obj[configKey::dns1] = dns1;
}
if (!dns2.isEmpty()) {
obj[configKey::dns2] = dns2;
}
if (crc > 0) {
obj[configKey::crc] = crc;
}
return obj;
}
ApiV1ServerConfig ApiV1ServerConfig::fromJson(const QJsonObject& json)
{
ApiV1ServerConfig config;
config.name = json.value(configKey::name).toString();
config.description = json.value(configKey::description).toString();
config.protocol = json.value(apiDefs::key::protocol).toString();
config.apiEndpoint = json.value(apiDefs::key::apiEndpoint).toString();
config.apiKey = json.value(apiDefs::key::apiKey).toString();
config.configVersion = json.value(configKey::configVersion).toInt(1);
config.hostName = json.value(configKey::hostName).toString();
QJsonArray containersArray = json.value(configKey::containers).toArray();
for (const QJsonValue& val : containersArray) {
QJsonObject containerObj = val.toObject();
ContainerConfig containerConfig = ContainerConfig::fromJson(containerObj);
QString containerStr = containerObj.value(configKey::container).toString();
DockerContainer container = ContainerUtils::containerFromString(containerStr);
config.containers.insert(container, containerConfig);
}
QString defaultContainerStr = json.value(configKey::defaultContainer).toString();
config.defaultContainer = ContainerUtils::containerFromString(defaultContainerStr);
config.dns1 = json.value(configKey::dns1).toString();
config.dns2 = json.value(configKey::dns2).toString();
config.crc = json.value(configKey::crc).toInt(0);
return config;
}
} // namespace amnezia
@@ -0,0 +1,47 @@
#ifndef APIV1SERVERCONFIG_H
#define APIV1SERVERCONFIG_H
#include <QJsonObject>
#include <QMap>
#include "core/utils/containerEnum.h"
#include "core/utils/containers/containerUtils.h"
#include "core/utils/protocolEnum.h"
#include "core/models/containerConfig.h"
#include "core/utils/api/apiEnums.h"
#include "core/utils/constants/apiKeys.h"
#include "core/utils/constants/apiConstants.h"
namespace amnezia
{
using namespace ContainerEnumNS;
struct ApiV1ServerConfig {
QString description;
QString hostName;
QMap<DockerContainer, ContainerConfig> containers;
DockerContainer defaultContainer;
QString dns1;
QString dns2;
QString name;
QString protocol;
QString apiEndpoint;
QString apiKey;
int crc;
int configVersion;
bool isPremium() const;
bool isFree() const;
QString vpnKey() const;
bool hasContainers() const;
ContainerConfig containerConfig(DockerContainer container) const;
QJsonObject toJson() const;
static ApiV1ServerConfig fromJson(const QJsonObject& json);
};
} // namespace amnezia
#endif // APIV1SERVERCONFIG_H
@@ -0,0 +1,170 @@
#include "apiV2ServerConfig.h"
#include <QJsonArray>
#include <QJsonDocument>
#include "core/utils/containerEnum.h"
#include "core/utils/containers/containerUtils.h"
#include "core/utils/protocolEnum.h"
#include "core/utils/protocolEnum.h"
#include "core/protocols/protocolUtils.h"
#include "core/utils/constants/configKeys.h"
#include "core/utils/constants/protocolConstants.h"
#include "core/utils/api/apiUtils.h"
#include "core/models/api/apiConfig.h"
#include "core/models/api/authData.h"
namespace amnezia
{
using namespace ContainerEnumNS;
QString ApiV2ServerConfig::vpnKey() const
{
if (!apiConfig.vpnKey.isEmpty()) {
return apiConfig.vpnKey;
}
QJsonObject json = toJson();
return apiUtils::getPremiumV2VpnKey(json);
}
QString ApiV2ServerConfig::serviceType() const
{
return apiConfig.serviceType;
}
QString ApiV2ServerConfig::serviceProtocol() const
{
return apiConfig.serviceProtocol;
}
bool ApiV2ServerConfig::isPremium() const
{
return apiConfig.isPremium();
}
bool ApiV2ServerConfig::isFree() const
{
return apiConfig.isFree();
}
bool ApiV2ServerConfig::isExternalPremium() const
{
return apiConfig.isExternalPremium();
}
bool ApiV2ServerConfig::hasContainers() const
{
return !containers.isEmpty();
}
ContainerConfig ApiV2ServerConfig::containerConfig(DockerContainer container) const
{
if (!containers.contains(container)) {
return ContainerConfig{};
}
return containers.value(container);
}
QJsonObject ApiV2ServerConfig::toJson() const
{
QJsonObject obj;
if (!name.isEmpty()) {
obj[configKey::name] = name;
}
if (nameOverriddenByUser) {
obj[configKey::nameOverriddenByUser] = true;
}
if (!description.isEmpty()) {
obj[configKey::description] = description;
}
obj[configKey::configVersion] = configVersion;
if (!hostName.isEmpty()) {
obj[configKey::hostName] = hostName;
}
QJsonArray containersArray;
for (auto it = containers.begin(); it != containers.end(); ++it) {
QJsonObject containerObj = it.value().toJson();
containersArray.append(containerObj);
}
if (!containersArray.isEmpty()) {
obj[configKey::containers] = containersArray;
}
if (defaultContainer != DockerContainer::None) {
obj[configKey::defaultContainer] = ContainerUtils::containerToString(defaultContainer);
}
if (!dns1.isEmpty()) {
obj[configKey::dns1] = dns1;
}
if (!dns2.isEmpty()) {
obj[configKey::dns2] = dns2;
}
if (crc > 0) {
obj[configKey::crc] = crc;
}
QJsonObject apiConfigObj = apiConfig.toJson();
if (!apiConfigObj.isEmpty()) {
obj[apiDefs::key::apiConfig] = apiConfigObj;
}
QJsonObject authDataObj = authData.toJson();
if (!authDataObj.isEmpty()) {
obj[QLatin1String("auth_data")] = authDataObj;
}
return obj;
}
ApiV2ServerConfig ApiV2ServerConfig::fromJson(const QJsonObject& json)
{
ApiV2ServerConfig config;
config.name = json.value(configKey::name).toString();
config.nameOverriddenByUser = json.value(configKey::nameOverriddenByUser).toBool(false);
config.description = json.value(configKey::description).toString();
config.configVersion = json.value(configKey::configVersion).toInt(2);
config.hostName = json.value(configKey::hostName).toString();
QJsonArray containersArray = json.value(configKey::containers).toArray();
for (const QJsonValue& val : containersArray) {
QJsonObject containerObj = val.toObject();
ContainerConfig containerConfig = ContainerConfig::fromJson(containerObj);
QString containerStr = containerObj.value(configKey::container).toString();
DockerContainer container = ContainerUtils::containerFromString(containerStr);
config.containers.insert(container, containerConfig);
}
QString defaultContainerStr = json.value(configKey::defaultContainer).toString();
config.defaultContainer = ContainerUtils::containerFromString(defaultContainerStr);
config.dns1 = json.value(configKey::dns1).toString();
config.dns2 = json.value(configKey::dns2).toString();
config.crc = json.value(configKey::crc).toInt(0);
QJsonObject apiConfigObj = json.value(apiDefs::key::apiConfig).toObject();
if (!apiConfigObj.isEmpty()) {
config.apiConfig = ApiConfig::fromJson(apiConfigObj);
}
QJsonObject authDataObj = json.value(QLatin1String("auth_data")).toObject();
if (!authDataObj.isEmpty()) {
config.authData = AuthData::fromJson(authDataObj);
}
return config;
}
} // namespace amnezia
@@ -0,0 +1,52 @@
#ifndef APIV2SERVERCONFIG_H
#define APIV2SERVERCONFIG_H
#include <QJsonObject>
#include <QMap>
#include "core/utils/containerEnum.h"
#include "core/utils/containers/containerUtils.h"
#include "core/utils/protocolEnum.h"
#include "core/models/containerConfig.h"
#include "core/models/api/apiConfig.h"
#include "core/models/api/authData.h"
#include "core/utils/api/apiEnums.h"
#include "core/utils/constants/apiKeys.h"
#include "core/utils/constants/apiConstants.h"
namespace amnezia
{
using namespace ContainerEnumNS;
struct ApiV2ServerConfig {
QString description;
QString hostName;
QMap<DockerContainer, ContainerConfig> containers;
DockerContainer defaultContainer;
QString dns1;
QString dns2;
QString name;
bool nameOverriddenByUser = false;
int crc;
int configVersion;
ApiConfig apiConfig;
AuthData authData;
QString vpnKey() const;
QString serviceType() const;
QString serviceProtocol() const;
bool isPremium() const;
bool isFree() const;
bool isExternalPremium() const;
bool hasContainers() const;
ContainerConfig containerConfig(DockerContainer container) const;
QJsonObject toJson() const;
static ApiV2ServerConfig fromJson(const QJsonObject& json);
};
} // namespace amnezia
#endif // APIV2SERVERCONFIG_H
+23
View File
@@ -0,0 +1,23 @@
#include "authData.h"
namespace amnezia
{
QJsonObject AuthData::toJson() const
{
QJsonObject obj;
if (!apiKey.isEmpty()) {
obj[apiDefs::key::apiKey] = apiKey;
}
return obj;
}
AuthData AuthData::fromJson(const QJsonObject& json)
{
AuthData data;
data.apiKey = json.value(apiDefs::key::apiKey).toString();
return data;
}
} // namespace amnezia
+24
View File
@@ -0,0 +1,24 @@
#ifndef AUTHDATA_H
#define AUTHDATA_H
#include <QJsonObject>
#include <QString>
#include "core/utils/api/apiEnums.h"
#include "core/utils/constants/apiKeys.h"
#include "core/utils/constants/apiConstants.h"
namespace amnezia
{
struct AuthData {
QString apiKey;
QJsonObject toJson() const;
static AuthData fromJson(const QJsonObject& json);
};
} // namespace amnezia
#endif // AUTHDATA_H