Merge branch 'dev' of github-amnezia:amnezia-vpn/amnezia-client into integrate-mtproxy

client/core/models/api/apiConfig.h

@@ -6,7 +6,7 @@
 #include <QString>
 #include <QDateTime>
 
-#include "core/utils/api/apiEnums.h"
+#include "core/utils/serverConfigUtils.h"
 #include "core/utils/constants/apiKeys.h"
 #include "core/utils/constants/apiConstants.h"
 

client/core/models/api/apiV1ServerConfig.cpp

@@ -1,140 +0,0 @@
-#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
-

client/core/models/api/apiV1ServerConfig.h

@@ -1,47 +0,0 @@
-#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
-

client/core/models/api/apiV2ServerConfig.cpp

@@ -80,6 +80,9 @@ QJsonObject ApiV2ServerConfig::toJson() const
     if (!description.isEmpty()) {
         obj[configKey::description] = description;
     }
+    if (!displayName.isEmpty()) {
+        obj[configKey::displayName] = displayName;
+    }
     
     obj[configKey::configVersion] = configVersion;
     
@@ -131,6 +134,7 @@ ApiV2ServerConfig ApiV2ServerConfig::fromJson(const QJsonObject& json)
     config.name = json.value(configKey::name).toString();
     config.nameOverriddenByUser = json.value(configKey::nameOverriddenByUser).toBool(false);
     config.description = json.value(configKey::description).toString();
+    config.displayName = json.value(configKey::displayName).toString();
     config.configVersion = json.value(configKey::configVersion).toInt(2);
     config.hostName = json.value(configKey::hostName).toString();
     
@@ -163,6 +167,10 @@ ApiV2ServerConfig ApiV2ServerConfig::fromJson(const QJsonObject& json)
         config.authData = AuthData::fromJson(authDataObj);
     }
     
+    if (config.displayName.isEmpty()) {
+        config.displayName = config.name.isEmpty() ? config.description : config.name;
+    }
+    
     return config;
 }
 

client/core/models/api/apiV2ServerConfig.h

@@ -10,7 +10,7 @@
 #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/serverConfigUtils.h"
 #include "core/utils/constants/apiKeys.h"
 #include "core/utils/constants/apiConstants.h"
 
@@ -21,6 +21,7 @@ using namespace ContainerEnumNS;
 
 struct ApiV2ServerConfig {
     QString description;
+    QString displayName;
     QString hostName;
     QMap<DockerContainer, ContainerConfig> containers;
     DockerContainer defaultContainer;

client/core/models/api/authData.h

@@ -4,7 +4,7 @@
 #include <QJsonObject>
 #include <QString>
 
-#include "core/utils/api/apiEnums.h"
+#include "core/utils/serverConfigUtils.h"
 #include "core/utils/constants/apiKeys.h"
 #include "core/utils/constants/apiConstants.h"
 

client/core/models/api/legacyApiServerConfig.cpp

@@ -0,0 +1,43 @@
+#include "legacyApiServerConfig.h"
+
+#include "core/utils/constants/apiKeys.h"
+#include "core/utils/constants/configKeys.h"
+
+namespace amnezia
+{
+
+bool LegacyApiServerConfig::hasContainers() const
+{
+    return !containers.isEmpty();
+}
+
+ContainerConfig LegacyApiServerConfig::containerConfig(DockerContainer container) const
+{
+    if (!containers.contains(container)) {
+        return ContainerConfig{};
+    }
+    return containers.value(container);
+}
+
+LegacyApiServerConfig LegacyApiServerConfig::fromJson(const QJsonObject &json)
+{
+    LegacyApiServerConfig config;
+
+    config.name = json.value(configKey::name).toString();
+    config.description = json.value(configKey::description).toString();
+    config.displayName = json.value(configKey::displayName).toString();
+    config.hostName = json.value(configKey::hostName).toString();
+
+    config.crc = json.value(configKey::crc).toInt(0);
+
+    config.configVersion = json.value(configKey::configVersion).toInt(1);
+    config.apiEndpoint = json.value(apiDefs::key::apiEndpoint).toString();
+
+    if (config.displayName.isEmpty()) {
+        config.displayName = config.name.isEmpty() ? config.description : config.name;
+    }
+
+    return config;
+}
+
+} // namespace amnezia

client/core/models/api/legacyApiServerConfig.h

@@ -0,0 +1,38 @@
+#ifndef LEGACYAPISERVERCONFIG_H
+#define LEGACYAPISERVERCONFIG_H
+
+#include <QJsonObject>
+#include <QMap>
+
+#include "core/utils/containerEnum.h"
+#include "core/utils/protocolEnum.h"
+#include "core/models/containerConfig.h"
+
+namespace amnezia
+{
+
+using namespace ContainerEnumNS;
+
+struct LegacyApiServerConfig {
+    QString description;
+    QString displayName;
+    QString hostName;
+    QMap<DockerContainer, ContainerConfig> containers;
+    DockerContainer defaultContainer = DockerContainer::None;
+    QString dns1;
+    QString dns2;
+
+    QString name;
+    int crc = 0;
+
+    int configVersion = 0;
+    QString apiEndpoint;
+
+    bool hasContainers() const;
+    ContainerConfig containerConfig(DockerContainer container) const;
+    static LegacyApiServerConfig fromJson(const QJsonObject &json);
+};
+
+} // namespace amnezia
+
+#endif // LEGACYAPISERVERCONFIG_H

client/core/models/selfhosted/nativeServerConfig.cpp

@@ -35,6 +35,9 @@ QJsonObject NativeServerConfig::toJson() const
     if (!description.isEmpty()) {
         obj[configKey::description] = this->description;
     }
+    if (!displayName.isEmpty()) {
+        obj[configKey::displayName] = displayName;
+    }
     if (!hostName.isEmpty()) {
         obj[configKey::hostName] = hostName;
     }
@@ -67,6 +70,7 @@ NativeServerConfig NativeServerConfig::fromJson(const QJsonObject& json)
     NativeServerConfig config;
     
     config.description = json.value(configKey::description).toString();
+    config.displayName = json.value(configKey::displayName).toString();
     config.hostName = json.value(configKey::hostName).toString();
     
     QJsonArray containersArray = json.value(configKey::containers).toArray();
@@ -86,6 +90,10 @@ NativeServerConfig NativeServerConfig::fromJson(const QJsonObject& json)
     config.dns1 = json.value(configKey::dns1).toString();
     config.dns2 = json.value(configKey::dns2).toString();
     
+    if (config.displayName.isEmpty()) {
+        config.displayName = config.description.isEmpty() ? config.hostName : config.description;
+    }
+    
     return config;
 }
 

client/core/models/selfhosted/nativeServerConfig.h

@@ -16,6 +16,7 @@ using namespace ContainerEnumNS;
 
 struct NativeServerConfig {
     QString description;
+    QString displayName;
     QString hostName;
     QMap<DockerContainer, ContainerConfig> containers;
     DockerContainer defaultContainer;

client/core/models/selfhosted/selfHostedAdminServerConfig.cpp

@@ -0,0 +1,170 @@
+#include "selfHostedAdminServerConfig.h"
+
+#include <QJsonArray>
+
+#include "core/protocols/protocolUtils.h"
+#include "core/utils/constants/configKeys.h"
+#include "core/utils/constants/protocolConstants.h"
+#include "core/utils/containerEnum.h"
+#include "core/utils/containers/containerUtils.h"
+#include "core/utils/protocolEnum.h"
+#include "core/utils/networkUtilities.h"
+
+namespace amnezia
+{
+
+using namespace ContainerEnumNS;
+
+bool SelfHostedAdminServerConfig::hasCredentials() const
+{
+    return !userName.isEmpty() && !password.isEmpty() && port > 0;
+}
+
+bool SelfHostedAdminServerConfig::isReadOnly() const
+{
+    return !hasCredentials();
+}
+
+ServerCredentials SelfHostedAdminServerConfig::credentials() const
+{
+    ServerCredentials creds;
+    creds.hostName = hostName;
+    creds.userName = userName;
+    creds.secretData = password;
+    creds.port = port;
+    return creds;
+}
+
+bool SelfHostedAdminServerConfig::hasContainers() const
+{
+    return !containers.isEmpty();
+}
+
+ContainerConfig SelfHostedAdminServerConfig::containerConfig(DockerContainer container) const
+{
+    if (!containers.contains(container)) {
+        return ContainerConfig{};
+    }
+    return containers.value(container);
+}
+
+void SelfHostedAdminServerConfig::updateContainerConfig(DockerContainer container, const ContainerConfig &config)
+{
+    containers[container] = config;
+}
+
+void SelfHostedAdminServerConfig::clearCachedClientProfile(DockerContainer container)
+{
+    if (ContainerUtils::containerService(container) == ServiceType::Other) {
+        return;
+    }
+
+    ContainerConfig cleared = containerConfig(container);
+    cleared.protocolConfig.clearClientConfig();
+    containers[container] = cleared;
+}
+
+QPair<QString, QString> SelfHostedAdminServerConfig::getDnsPair(bool isAmneziaDnsEnabled, const QString &primaryDns,
+                                                                const QString &secondaryDns) const
+{
+    QString d1 = dns1;
+    QString d2 = dns2;
+    const bool dnsOnServer = containers.contains(DockerContainer::Dns);
+
+    if (d1.isEmpty() || !NetworkUtilities::checkIPv4Format(d1)) {
+        d1 = (isAmneziaDnsEnabled && dnsOnServer) ? protocols::dns::amneziaDnsIp : primaryDns;
+    }
+    if (d2.isEmpty() || !NetworkUtilities::checkIPv4Format(d2)) {
+        d2 = secondaryDns;
+    }
+    return { d1, d2 };
+}
+
+QJsonObject SelfHostedAdminServerConfig::toJson() const
+{
+    QJsonObject obj;
+
+    if (!description.isEmpty()) {
+        obj[configKey::description] = this->description;
+    }
+    if (!displayName.isEmpty()) {
+        obj[configKey::displayName] = displayName;
+    }
+    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 (!userName.isEmpty()) {
+        obj[configKey::userName] = userName;
+    }
+    if (!password.isEmpty()) {
+        obj[configKey::password] = password;
+    }
+    if (port > 0) {
+        obj[configKey::port] = port;
+    }
+
+    return obj;
+}
+
+SelfHostedAdminServerConfig SelfHostedAdminServerConfig::fromJson(const QJsonObject &json)
+{
+    SelfHostedAdminServerConfig config;
+
+    config.description = json.value(configKey::description).toString();
+    config.displayName = json.value(configKey::displayName).toString();
+    config.hostName = json.value(configKey::hostName).toString();
+
+    QJsonArray containersArray = json.value(configKey::containers).toArray();
+    for (const QJsonValue &val : containersArray) {
+        QJsonObject containerObj = val.toObject();
+        ContainerConfig cc = ContainerConfig::fromJson(containerObj);
+
+        QString containerStr = containerObj.value(configKey::container).toString();
+        DockerContainer container = ContainerUtils::containerFromString(containerStr);
+
+        config.containers.insert(container, cc);
+    }
+
+    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.userName = json.value(configKey::userName).toString();
+    config.password = json.value(configKey::password).toString();
+    if (json.contains(configKey::port)) {
+        config.port = json.value(configKey::port).toInt();
+    } else {
+        config.port = 0;
+    }
+
+    if (config.displayName.isEmpty()) {
+        config.displayName = config.description.isEmpty() ? config.hostName : config.description;
+    }
+
+    return config;
+}
+
+} // namespace amnezia

client/core/models/selfhosted/selfHostedAdminServerConfig.h

@@ -0,0 +1,53 @@
+#ifndef SELFHOSTEDADMINSERVERCONFIG_H
+#define SELFHOSTEDADMINSERVERCONFIG_H
+
+#include <QJsonObject>
+#include <QMap>
+#include <QPair>
+
+#include "core/utils/containerEnum.h"
+#include "core/utils/containers/containerUtils.h"
+#include "core/utils/protocolEnum.h"
+#include "core/models/containerConfig.h"
+#include "core/utils/errorCodes.h"
+#include "core/utils/routeModes.h"
+#include "core/utils/commonStructs.h"
+
+namespace amnezia
+{
+
+using namespace ContainerEnumNS;
+
+struct SelfHostedAdminServerConfig {
+    QString description;
+    QString displayName;
+    QString hostName;
+    QMap<DockerContainer, ContainerConfig> containers;
+    DockerContainer defaultContainer;
+    QString dns1;
+    QString dns2;
+
+    QString userName;
+    QString password;
+    int port = 0;
+
+    bool hasCredentials() const;
+    bool isReadOnly() const;
+    ServerCredentials credentials() const;
+    bool hasContainers() const;
+    ContainerConfig containerConfig(DockerContainer container) const;
+
+    void updateContainerConfig(DockerContainer container, const ContainerConfig &config);
+
+    void clearCachedClientProfile(DockerContainer container);
+
+    QPair<QString, QString> getDnsPair(bool isAmneziaDnsEnabled, const QString &primaryDns,
+                                       const QString &secondaryDns) const;
+
+    QJsonObject toJson() const;
+    static SelfHostedAdminServerConfig fromJson(const QJsonObject &json);
+};
+
+} // namespace amnezia
+
+#endif // SELFHOSTEDADMINSERVERCONFIG_H

client/core/models/selfhosted/selfHostedUserServerConfig.cpp

@@ -1,53 +1,40 @@
-#include "selfHostedServerConfig.h"
+#include "selfHostedUserServerConfig.h"
 
 #include <QJsonArray>
-#include <QJsonDocument>
-#include <stdexcept>
 
-#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/containerEnum.h"
+#include "core/utils/containers/containerUtils.h"
+#include "core/utils/protocolEnum.h"
 
 namespace amnezia
 {
 
 using namespace ContainerEnumNS;
 
-bool SelfHostedServerConfig::hasCredentials() const
+bool SelfHostedUserServerConfig::hasCredentials() const
 {
-    return userName.has_value() && password.has_value() && port.has_value();
+    return false;
 }
 
-bool SelfHostedServerConfig::isReadOnly() const
+bool SelfHostedUserServerConfig::isReadOnly() const
 {
-    return !hasCredentials();
+    return true;
 }
 
-std::optional<ServerCredentials> SelfHostedServerConfig::credentials() const
+std::optional<ServerCredentials> SelfHostedUserServerConfig::credentials() const
 {
-    if (!hasCredentials()) {
-        return std::nullopt;
-    }
-    
-    ServerCredentials creds;
-    creds.hostName = hostName;
-    creds.userName = userName.value();
-    creds.secretData = password.value();
-    creds.port = port.value();
-    
-    return creds;
+    return std::nullopt;
 }
 
-bool SelfHostedServerConfig::hasContainers() const
+bool SelfHostedUserServerConfig::hasContainers() const
 {
     return !containers.isEmpty();
 }
 
-ContainerConfig SelfHostedServerConfig::containerConfig(DockerContainer container) const
+ContainerConfig SelfHostedUserServerConfig::containerConfig(DockerContainer container) const
 {
     if (!containers.contains(container)) {
         return ContainerConfig{};
@@ -55,17 +42,20 @@ ContainerConfig SelfHostedServerConfig::containerConfig(DockerContainer containe
     return containers.value(container);
 }
 
-QJsonObject SelfHostedServerConfig::toJson() const
+QJsonObject SelfHostedUserServerConfig::toJson() const
 {
     QJsonObject obj;
-    
+
     if (!description.isEmpty()) {
         obj[configKey::description] = this->description;
     }
+    if (!displayName.isEmpty()) {
+        obj[configKey::displayName] = displayName;
+    }
     if (!hostName.isEmpty()) {
         obj[configKey::hostName] = hostName;
     }
-    
+
     QJsonArray containersArray;
     for (auto it = containers.begin(); it != containers.end(); ++it) {
         QJsonObject containerObj = it.value().toJson();
@@ -74,67 +64,51 @@ QJsonObject SelfHostedServerConfig::toJson() const
     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 (userName.has_value()) {
-        obj[configKey::userName] = userName.value();
-    }
-    if (password.has_value()) {
-        obj[configKey::password] = password.value();
-    }
-    if (port.has_value()) {
-        obj[configKey::port] = port.value();
-    }
-    
+
     return obj;
 }
 
-SelfHostedServerConfig SelfHostedServerConfig::fromJson(const QJsonObject& json)
+SelfHostedUserServerConfig SelfHostedUserServerConfig::fromJson(const QJsonObject &json)
 {
-    SelfHostedServerConfig config;
-    
+    SelfHostedUserServerConfig config;
+
     config.description = json.value(configKey::description).toString();
+    config.displayName = json.value(configKey::displayName).toString();
     config.hostName = json.value(configKey::hostName).toString();
-    
+
     QJsonArray containersArray = json.value(configKey::containers).toArray();
-    for (const QJsonValue& val : containersArray) {
+    for (const QJsonValue &val : containersArray) {
         QJsonObject containerObj = val.toObject();
-        ContainerConfig containerConfig = ContainerConfig::fromJson(containerObj);
-        
+        ContainerConfig cc = ContainerConfig::fromJson(containerObj);
+
         QString containerStr = containerObj.value(configKey::container).toString();
         DockerContainer container = ContainerUtils::containerFromString(containerStr);
-        
-        config.containers.insert(container, containerConfig);
+
+        config.containers.insert(container, cc);
     }
-    
+
     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();
-    
-    if (json.contains(configKey::userName)) {
-        config.userName = json.value(configKey::userName).toString();
+
+    if (config.displayName.isEmpty()) {
+        config.displayName = config.description.isEmpty() ? config.hostName : config.description;
     }
-    if (json.contains(configKey::password)) {
-        config.password = json.value(configKey::password).toString();
-    }
-    if (json.contains(configKey::port)) {
-        config.port = json.value(configKey::port).toInt();
-    }
-    
+
     return config;
 }
 
 } // namespace amnezia
-

client/core/models/selfhosted/selfHostedUserServerConfig.h

@@ -1,5 +1,5 @@
-#ifndef SELFHOSTEDSERVERCONFIG_H
-#define SELFHOSTEDSERVERCONFIG_H
+#ifndef SELFHOSTEDUSERSERVERCONFIG_H
+#define SELFHOSTEDUSERSERVERCONFIG_H
 
 #include <QJsonObject>
 #include <QMap>
@@ -9,8 +9,6 @@
 #include "core/utils/containers/containerUtils.h"
 #include "core/utils/protocolEnum.h"
 #include "core/models/containerConfig.h"
-#include "core/utils/errorCodes.h"
-#include "core/utils/routeModes.h"
 #include "core/utils/commonStructs.h"
 
 namespace amnezia
@@ -18,28 +16,24 @@ namespace amnezia
 
 using namespace ContainerEnumNS;
 
-struct SelfHostedServerConfig {
+struct SelfHostedUserServerConfig {
     QString description;
+    QString displayName;
     QString hostName;
     QMap<DockerContainer, ContainerConfig> containers;
     DockerContainer defaultContainer;
     QString dns1;
     QString dns2;
-    
-    std::optional<QString> userName;
-    std::optional<QString> password;
-    std::optional<int> port;
-    
+
     bool hasCredentials() const;
     bool isReadOnly() const;
     std::optional<ServerCredentials> credentials() const;
     bool hasContainers() const;
     ContainerConfig containerConfig(DockerContainer container) const;
     QJsonObject toJson() const;
-    static SelfHostedServerConfig fromJson(const QJsonObject& json);
+    static SelfHostedUserServerConfig fromJson(const QJsonObject &json);
 };
 
 } // namespace amnezia
 
-#endif // SELFHOSTEDSERVERCONFIG_H
-
+#endif // SELFHOSTEDUSERSERVERCONFIG_H

client/core/models/serverConfig.cpp

@@ -1,234 +0,0 @@
-#include "serverConfig.h"
-
-#include "core/utils/api/apiUtils.h"
-#include "core/utils/networkUtilities.h"
-#include "core/models/selfhosted/selfHostedServerConfig.h"
-#include "core/models/selfhosted/nativeServerConfig.h"
-#include "core/models/api/apiV1ServerConfig.h"
-#include "core/models/api/apiV2ServerConfig.h"
-#include "core/utils/protocolEnum.h"
-#include "core/protocols/protocolUtils.h"
-#include "core/utils/constants/configKeys.h"
-#include "core/utils/constants/protocolConstants.h"
-
-namespace amnezia
-{
-
-using namespace ContainerEnumNS;
-
-QString ServerConfig::description() const
-{
-    return std::visit([](const auto& v) { return v.description; }, data);
-}
-
-QString ServerConfig::hostName() const
-{
-    return std::visit([](const auto& v) { return v.hostName; }, data);
-}
-
-QString ServerConfig::displayName() const
-{
-    if (isApiV1()) {
-        const auto *apiV1 = as<ApiV1ServerConfig>();
-        return apiV1 ? apiV1->name : description();
-    }
-    if (isApiV2()) {
-        const auto *apiV2 = as<ApiV2ServerConfig>();
-        return apiV2 ? apiV2->name : description();
-    }
-    QString name = description();
-    return name.isEmpty() ? hostName() : name;
-}
-
-QMap<DockerContainer, ContainerConfig> ServerConfig::containers() const
-{
-    return std::visit([](const auto& v) { return v.containers; }, data);
-}
-
-DockerContainer ServerConfig::defaultContainer() const
-{
-    return std::visit([](const auto& v) { return v.defaultContainer; }, data);
-}
-
-QString ServerConfig::dns1() const
-{
-    return std::visit([](const auto& v) { return v.dns1; }, data);
-}
-
-QString ServerConfig::dns2() const
-{
-    return std::visit([](const auto& v) { return v.dns2; }, data);
-}
-
-bool ServerConfig::hasContainers() const
-{
-    return std::visit([](const auto& v) { return v.hasContainers(); }, data);
-}
-
-ContainerConfig ServerConfig::containerConfig(DockerContainer container) const
-{
-    return std::visit([container](const auto& v) { return v.containerConfig(container); }, data);
-}
-
-int ServerConfig::crc() const
-{
-    return std::visit([](const auto& v) -> int {
-        using T = std::decay_t<decltype(v)>;
-        if constexpr (std::is_same_v<T, ApiV1ServerConfig> ||
-                      std::is_same_v<T, ApiV2ServerConfig>) {
-            return v.crc;
-        }
-        return 0;
-    }, data);
-}
-
-int ServerConfig::configVersion() const
-{
-    return std::visit([](const auto& v) -> int {
-        using T = std::decay_t<decltype(v)>;
-        if constexpr (std::is_same_v<T, ApiV1ServerConfig>) {
-            return apiDefs::ConfigSource::Telegram;
-        } else if constexpr (std::is_same_v<T, ApiV2ServerConfig>) {
-            return apiDefs::ConfigSource::AmneziaGateway;
-        }
-        return 0; // SelfHostedServerConfig or NativeServerConfig
-    }, data);
-}
-
-bool ServerConfig::isSelfHosted() const
-{
-    return std::holds_alternative<SelfHostedServerConfig>(data);
-}
-
-bool ServerConfig::isNative() const
-{
-    return std::holds_alternative<NativeServerConfig>(data);
-}
-
-bool ServerConfig::isApiV1() const
-{
-    return std::holds_alternative<ApiV1ServerConfig>(data);
-}
-
-bool ServerConfig::isApiV2() const
-{
-    return std::holds_alternative<ApiV2ServerConfig>(data);
-}
-
-bool ServerConfig::isApiConfig() const
-{
-    return isApiV1() || isApiV2();
-}
-
-QJsonObject ServerConfig::toJson() const
-{
-    return std::visit([](const auto& v) { return v.toJson(); }, data);
-}
-
-ServerConfig ServerConfig::fromJson(const QJsonObject& json)
-{
-    apiDefs::ConfigType configType = apiUtils::getConfigType(json);
-    
-    switch (configType) {
-    case apiDefs::ConfigType::SelfHosted: {
-        bool hasThirdPartyConfig = false;
-        QJsonArray containersArray = json.value(configKey::containers).toArray();
-        for (const QJsonValue& val : containersArray) {
-            QJsonObject containerObj = val.toObject();
-            for (auto it = containerObj.begin(); it != containerObj.end(); ++it) {
-                QString key = it.key();
-                if (key != configKey::container) {
-                    QJsonObject protocolObj = it.value().toObject();
-                    if (protocolObj.contains(configKey::isThirdPartyConfig) && 
-                        protocolObj.value(configKey::isThirdPartyConfig).toBool()) {
-                        hasThirdPartyConfig = true;
-                        break;
-                    }
-                }
-            }
-            if (hasThirdPartyConfig) {
-                break;
-            }
-        }
-        
-        if (hasThirdPartyConfig) {
-            return ServerConfig{NativeServerConfig::fromJson(json)};
-        } else {
-            return ServerConfig{SelfHostedServerConfig::fromJson(json)};
-        }
-    }
-    case apiDefs::ConfigType::AmneziaPremiumV1:
-    case apiDefs::ConfigType::AmneziaFreeV2:
-        return ServerConfig{ApiV1ServerConfig::fromJson(json)};
-    case apiDefs::ConfigType::AmneziaPremiumV2:
-    case apiDefs::ConfigType::AmneziaFreeV3:
-    case apiDefs::ConfigType::ExternalPremium:
-        return ServerConfig{ApiV2ServerConfig::fromJson(json)};
-    default: {
-        // Check if any container has isThirdPartyConfig
-        bool hasThirdPartyConfig = false;
-        QJsonArray containersArray = json.value(configKey::containers).toArray();
-        for (const QJsonValue& val : containersArray) {
-            QJsonObject containerObj = val.toObject();
-            // Check all protocol keys in the container object
-            for (auto it = containerObj.begin(); it != containerObj.end(); ++it) {
-                QString key = it.key();
-                if (key != configKey::container) {
-                    QJsonObject protocolObj = it.value().toObject();
-                    if (protocolObj.contains(configKey::isThirdPartyConfig) && 
-                        protocolObj.value(configKey::isThirdPartyConfig).toBool()) {
-                        hasThirdPartyConfig = true;
-                        break;
-                    }
-                }
-            }
-            if (hasThirdPartyConfig) {
-                break;
-            }
-        }
-        
-        if (hasThirdPartyConfig) {
-            return ServerConfig{NativeServerConfig::fromJson(json)};
-        } else {
-            return ServerConfig{SelfHostedServerConfig::fromJson(json)};
-        }
-    }
-    }
-}
-
-QPair<QString, QString> ServerConfig::getDnsPair(bool isAmneziaDnsEnabled,
-                                                 const QString &primaryDns,
-                                                 const QString &secondaryDns) const
-{
-    QPair<QString, QString> dns;
-    
-    QMap<DockerContainer, ContainerConfig> serverContainers = containers();
-    
-    bool isDnsContainerInstalled = false;
-    for (auto it = serverContainers.begin(); it != serverContainers.end(); ++it) {
-        if (it.key() == DockerContainer::Dns) {
-            isDnsContainerInstalled = true;
-            break;
-        }
-    }
-    
-    dns.first = dns1();
-    dns.second = dns2();
-    
-    if (dns.first.isEmpty() || !NetworkUtilities::checkIPv4Format(dns.first)) {
-        if (isAmneziaDnsEnabled && isDnsContainerInstalled) {
-            dns.first = protocols::dns::amneziaDnsIp;
-        } else {
-            dns.first = primaryDns;
-        }
-    }
-    
-    if (dns.second.isEmpty() || !NetworkUtilities::checkIPv4Format(dns.second)) {
-        dns.second = secondaryDns;
-    }
-    
-    return dns;
-}
-
-} // namespace amnezia
-

client/core/models/serverConfig.h

@@ -1,92 +0,0 @@
-#ifndef SERVERCONFIG_H
-#define SERVERCONFIG_H
-
-#include <variant>
-#include <QJsonObject>
-#include <QMap>
-
-#include "core/utils/containerEnum.h"
-#include "core/utils/containers/containerUtils.h"
-#include "core/utils/protocolEnum.h"
-#include "core/models/selfhosted/selfHostedServerConfig.h"
-#include "core/models/selfhosted/nativeServerConfig.h"
-#include "core/models/api/apiV1ServerConfig.h"
-#include "core/models/api/apiV2ServerConfig.h"
-#include "core/models/containerConfig.h"
-
-namespace amnezia
-{
-
-using namespace ContainerEnumNS;
-
-struct ServerConfig {
-    using Variant = std::variant<
-        SelfHostedServerConfig,
-        NativeServerConfig,
-        ApiV1ServerConfig,
-        ApiV2ServerConfig
-    >;
-    
-    Variant data;
-    
-    ServerConfig() = default;
-    ServerConfig(const Variant& v) : data(v) {}
-    ServerConfig(Variant&& v) : data(std::move(v)) {}
-    
-    template<typename T, typename = std::enable_if_t<!std::is_same<std::remove_cv_t<std::remove_reference_t<T>>, ServerConfig>::value>>
-    ServerConfig(const T& v) : data(v) {}
-    
-    template<typename T, typename = std::enable_if_t<!std::is_same<std::remove_cv_t<std::remove_reference_t<T>>, ServerConfig>::value>>
-    ServerConfig(T&& v) : data(std::forward<T>(v)) {}
-    
-    QString description() const;
-    QString hostName() const;
-    QString displayName() const;
-    QMap<DockerContainer, ContainerConfig> containers() const;
-    DockerContainer defaultContainer() const;
-    QString dns1() const;
-    QString dns2() const;
-    bool hasContainers() const;
-    ContainerConfig containerConfig(DockerContainer container) const;
-    
-    int crc() const;
-    int configVersion() const;
-    
-    bool isSelfHosted() const;
-    bool isNative() const;
-    bool isApiV1() const;
-    bool isApiV2() const;
-    bool isApiConfig() const;
-    
-    template<typename T>
-    T* as() {
-        return std::get_if<T>(&data);
-    }
-    
-    template<typename T>
-    const T* as() const {
-        return std::get_if<T>(&data);
-    }
-    
-    QJsonObject toJson() const;
-    static ServerConfig fromJson(const QJsonObject& json);
-    
-    template<typename Visitor>
-    auto visit(Visitor&& visitor) {
-        return std::visit(std::forward<Visitor>(visitor), data);
-    }
-    
-    template<typename Visitor>
-    auto visit(Visitor&& visitor) const {
-        return std::visit(std::forward<Visitor>(visitor), data);
-    }
-    
-    QPair<QString, QString> getDnsPair(bool isAmneziaDnsEnabled,
-                                       const QString &primaryDns,
-                                       const QString &secondaryDns) const;
-};
-
-} // namespace amnezia
-
-#endif // SERVERCONFIG_H
-

client/core/models/serverDescription.cpp

@@ -0,0 +1,187 @@
+#include "serverDescription.h"
+
+#include <QMap>
+
+#include "core/utils/serverConfigUtils.h"
+#include "core/utils/constants/apiKeys.h"
+#include "core/utils/constants/apiConstants.h"
+#include "core/utils/constants/protocolConstants.h"
+#include "core/utils/api/apiUtils.h"
+#include "core/utils/containers/containerUtils.h"
+#include "core/protocols/protocolUtils.h"
+#include "core/models/protocols/awgProtocolConfig.h"
+
+using namespace amnezia;
+
+namespace
+{
+
+bool computeHasInstalledVpnContainers(const QMap<DockerContainer, ContainerConfig> &containers)
+{
+    for (auto it = containers.begin(); it != containers.end(); ++it) {
+        const DockerContainer container = it.key();
+        if (ContainerUtils::containerService(container) == ServiceType::Vpn || container == DockerContainer::SSXray) {
+            return true;
+        }
+    }
+    return false;
+}
+
+template <typename T>
+ServerDescription buildBaseDescription(const T &server)
+{
+    ServerDescription row;
+    row.hostName = server.hostName;
+    row.defaultContainer = server.defaultContainer;
+    row.primaryDnsIsAmnezia = (server.dns1 == protocols::dns::amneziaDnsIp);
+    row.hasInstalledVpnContainers = computeHasInstalledVpnContainers(server.containers);
+    return row;
+}
+
+QString getBaseDescription(const QMap<DockerContainer, ContainerConfig> &containers,
+                         bool isAmneziaDnsEnabled,
+                         bool hasWriteAccess,
+                         bool primaryDnsIsAmnezia)
+{
+    QString description;
+    if (hasWriteAccess) {
+        const bool isDnsInstalled = containers.contains(DockerContainer::Dns);
+        if (isAmneziaDnsEnabled && isDnsInstalled) {
+            description += QStringLiteral("Amnezia DNS | ");
+        }
+    } else if (primaryDnsIsAmnezia) {
+        description += QStringLiteral("Amnezia DNS | ");
+    }
+    return description;
+}
+
+QString getProtocolName(DockerContainer defaultContainer, const QMap<DockerContainer, ContainerConfig> &containers)
+{
+    QString containerName = ContainerUtils::containerHumanNames().value(defaultContainer);
+    QString protocolVersion;
+
+    if (ContainerUtils::isAwgContainer(defaultContainer)) {
+        const auto it = containers.constFind(defaultContainer);
+        if (it != containers.cend()) {
+            if (const AwgProtocolConfig *awg = it->getAwgProtocolConfig()) {
+                protocolVersion = ProtocolUtils::getProtocolVersionString(awg->toJson());
+                if (defaultContainer == DockerContainer::Awg && !awg->serverConfig.isThirdPartyConfig) {
+                    containerName = QStringLiteral("AmneziaWG Legacy");
+                }
+            }
+        }
+    }
+
+    return containerName + protocolVersion + QStringLiteral(" | ");
+}
+
+} // namespace
+
+namespace amnezia
+{
+
+ServerDescription buildServerDescription(const SelfHostedAdminServerConfig &server, bool isAmneziaDnsEnabled)
+{
+    ServerDescription row = buildBaseDescription(server);
+    row.selfHostedSshCredentials.hostName = server.hostName;
+    row.selfHostedSshCredentials.userName = server.userName;
+    row.selfHostedSshCredentials.secretData = server.password;
+    row.selfHostedSshCredentials.port = server.port > 0 ? server.port : 22;
+
+    row.hasWriteAccess = !row.selfHostedSshCredentials.userName.isEmpty()
+                         && !row.selfHostedSshCredentials.secretData.isEmpty();
+
+    row.serverName = server.displayName;
+    row.baseDescription = getBaseDescription(server.containers, isAmneziaDnsEnabled, row.hasWriteAccess, row.primaryDnsIsAmnezia);
+
+    const QString protocolName = getProtocolName(server.defaultContainer, server.containers);
+    row.expandedServerDescription = row.baseDescription + row.hostName;
+    row.collapsedServerDescription = row.baseDescription + protocolName + row.hostName;
+    return row;
+}
+
+ServerDescription buildServerDescription(const SelfHostedUserServerConfig &server, bool isAmneziaDnsEnabled)
+{
+    ServerDescription row = buildBaseDescription(server);
+    row.selfHostedSshCredentials.hostName = server.hostName;
+    row.selfHostedSshCredentials.port = 22;
+    row.hasWriteAccess = false;
+
+    row.serverName = server.displayName;
+    row.baseDescription = getBaseDescription(server.containers, isAmneziaDnsEnabled, row.hasWriteAccess, row.primaryDnsIsAmnezia);
+
+    const QString protocolName = getProtocolName(server.defaultContainer, server.containers);
+    row.expandedServerDescription = row.baseDescription + row.hostName;
+    row.collapsedServerDescription = row.baseDescription + protocolName + row.hostName;
+    return row;
+}
+
+ServerDescription buildServerDescription(const NativeServerConfig &server, bool isAmneziaDnsEnabled)
+{
+    ServerDescription row = buildBaseDescription(server);
+    row.hasWriteAccess = false;
+
+    row.serverName = server.displayName;
+    row.baseDescription = getBaseDescription(server.containers, isAmneziaDnsEnabled, row.hasWriteAccess, row.primaryDnsIsAmnezia);
+
+    const QString protocolName = getProtocolName(server.defaultContainer, server.containers);
+    row.expandedServerDescription = row.baseDescription + row.hostName;
+    row.collapsedServerDescription = row.baseDescription + protocolName + row.hostName;
+    return row;
+}
+
+ServerDescription buildServerDescription(const LegacyApiServerConfig &server, bool /*isAmneziaDnsEnabled*/)
+{
+    ServerDescription row = buildBaseDescription(server);
+    row.configVersion = serverConfigUtils::ConfigSource::Telegram;
+    row.isApiV1 = true;
+    row.isServerFromGatewayApi = false;
+    row.hasWriteAccess = false;
+
+    row.serverName = server.displayName;
+    row.baseDescription = server.description;
+
+    const QString fullDescriptionForCollapsed = row.baseDescription;
+    row.collapsedServerDescription = fullDescriptionForCollapsed;
+    row.expandedServerDescription = fullDescriptionForCollapsed;
+    return row;
+}
+
+ServerDescription buildServerDescription(const ApiV2ServerConfig &server, bool /*isAmneziaDnsEnabled*/)
+{
+    ServerDescription row = buildBaseDescription(server);
+    row.configVersion = serverConfigUtils::ConfigSource::AmneziaGateway;
+    row.isApiV2 = true;
+    row.isServerFromGatewayApi = true;
+    row.isPremium = server.isPremium() || server.isExternalPremium();
+    row.hasWriteAccess = false;
+
+    row.serverName = server.displayName;
+    row.baseDescription = server.apiConfig.serverCountryCode.isEmpty() ? server.description : server.apiConfig.serverCountryName;
+
+    row.isCountrySelectionAvailable = !server.apiConfig.availableCountries.isEmpty();
+    row.apiAvailableCountries = server.apiConfig.availableCountries;
+    row.apiServerCountryCode = server.apiConfig.serverCountryCode;
+
+    row.isAdVisible = server.apiConfig.serviceInfo.isAdVisible;
+    row.adHeader = server.apiConfig.serviceInfo.adHeader;
+    row.adDescription = server.apiConfig.serviceInfo.adDescription;
+    row.adEndpoint = server.apiConfig.serviceInfo.adEndpoint;
+    row.isRenewalAvailable = server.apiConfig.serviceInfo.isRenewalAvailable;
+
+    if (!server.apiConfig.isInAppPurchase) {
+        if (server.apiConfig.subscriptionExpiredByServer) {
+            row.isSubscriptionExpired = true;
+        } else if (!server.apiConfig.subscription.endDate.isEmpty()) {
+            row.isSubscriptionExpired = apiUtils::isSubscriptionExpired(server.apiConfig.subscription.endDate);
+            row.isSubscriptionExpiringSoon = apiUtils::isSubscriptionExpiringSoon(server.apiConfig.subscription.endDate);
+        }
+    }
+
+    const QString fullDescriptionForCollapsed = row.baseDescription;
+    row.collapsedServerDescription = fullDescriptionForCollapsed;
+    row.expandedServerDescription = fullDescriptionForCollapsed;
+    return row;
+}
+
+} // namespace amnezia

client/core/models/serverDescription.h

@@ -0,0 +1,64 @@
+#ifndef SERVERDESCRIPTION_H
+#define SERVERDESCRIPTION_H
+
+#include <QString>
+#include <QJsonArray>
+
+#include "core/utils/containerEnum.h"
+#include "core/utils/selfhosted/sshSession.h"
+#include "core/models/selfhosted/selfHostedAdminServerConfig.h"
+#include "core/models/selfhosted/selfHostedUserServerConfig.h"
+#include "core/models/selfhosted/nativeServerConfig.h"
+#include "core/models/api/legacyApiServerConfig.h"
+#include "core/models/api/apiV2ServerConfig.h"
+
+namespace amnezia
+{
+
+struct ServerDescription
+{
+    QString serverId;
+
+    QString serverName;
+    QString baseDescription;
+    QString hostName;
+
+    int configVersion = 0;
+
+    ServerCredentials selfHostedSshCredentials;
+    bool hasWriteAccess = false;
+
+    bool primaryDnsIsAmnezia = false;
+    DockerContainer defaultContainer = DockerContainer::None;
+    bool hasInstalledVpnContainers = false;
+
+    bool isApiV1 = false;
+    bool isApiV2 = false;
+    bool isServerFromGatewayApi = false;
+    bool isPremium = false;
+
+    bool isCountrySelectionAvailable = false;
+    QJsonArray apiAvailableCountries;
+    QString apiServerCountryCode;
+
+    bool isAdVisible = false;
+    QString adHeader;
+    QString adDescription;
+    QString adEndpoint;
+    bool isRenewalAvailable = false;
+    bool isSubscriptionExpired = false;
+    bool isSubscriptionExpiringSoon = false;
+
+    QString collapsedServerDescription;
+    QString expandedServerDescription;
+};
+
+ServerDescription buildServerDescription(const SelfHostedAdminServerConfig &server, bool isAmneziaDnsEnabled);
+ServerDescription buildServerDescription(const SelfHostedUserServerConfig &server, bool isAmneziaDnsEnabled);
+ServerDescription buildServerDescription(const NativeServerConfig &server, bool isAmneziaDnsEnabled);
+ServerDescription buildServerDescription(const LegacyApiServerConfig &server, bool isAmneziaDnsEnabled);
+ServerDescription buildServerDescription(const ApiV2ServerConfig &server, bool isAmneziaDnsEnabled);
+
+} // namespace amnezia
+
+#endif