added exportController and PageShare

- added a blank PageSettingsProtocol

client/ui/controllers/exportController.cpp

@@ -0,0 +1,156 @@
+#include "exportController.h"
+
+#include <QBuffer>
+#include <QDataStream>
+#include <QDesktopServices>
+#include <QFile>
+#include <QFileDialog>
+#include <QFileInfo>
+#include <QImage>
+#include <QStandardPaths>
+
+#include "qrcodegen.hpp"
+
+ExportController::ExportController(const QSharedPointer<ServersModel> &serversModel,
+                                   const QSharedPointer<ContainersModel> &containersModel,
+                                   const std::shared_ptr<Settings> &settings,
+                                   const std::shared_ptr<VpnConfigurator> &configurator,
+                                   QObject *parent)
+    : QObject(parent)
+    , m_serversModel(serversModel)
+    , m_containersModel(containersModel)
+    , m_settings(settings)
+    , m_configurator(configurator)
+{}
+
+void ExportController::generateFullAccessConfig()
+{
+    int serverIndex = m_serversModel->getCurrentlyProcessedServerIndex();
+    QJsonObject config = m_settings->server(serverIndex);
+
+    QByteArray compressedConfig = QJsonDocument(config).toJson();
+    compressedConfig = qCompress(compressedConfig, 8);
+    m_amneziaCode = QString("vpn://%1")
+                        .arg(QString(compressedConfig.toBase64(QByteArray::Base64UrlEncoding
+                                                               | QByteArray::OmitTrailingEquals)));
+
+    m_qrCodes = generateQrCodeImageSeries(compressedConfig);
+}
+
+void ExportController::generateConnectionConfig()
+{
+    int serverIndex = m_serversModel->getCurrentlyProcessedServerIndex();
+    ServerCredentials credentials = m_serversModel->getCurrentlyProcessedServerCredentials();
+
+    DockerContainer container = static_cast<DockerContainer>(
+        m_containersModel->getCurrentlyProcessedContainerIndex());
+    QModelIndex containerModelIndex = m_containersModel->index(container);
+    QJsonObject containerConfig = qvariant_cast<QJsonObject>(
+        m_containersModel->data(containerModelIndex, ContainersModel::Roles::ConfigRole));
+    containerConfig.insert(config_key::container, ContainerProps::containerToString(container));
+
+    ErrorCode e = ErrorCode::NoError;
+    for (Proto p : ContainerProps::protocolsForContainer(container)) {
+        QJsonObject protoConfig = m_settings->protocolConfig(serverIndex, container, p);
+
+        QString cfg = m_configurator->genVpnProtocolConfig(credentials,
+                                                           container,
+                                                           containerConfig,
+                                                           p,
+                                                           &e);
+        if (e) {
+            cfg = "Error generating config";
+            break;
+        }
+        protoConfig.insert(config_key::last_config, cfg);
+        containerConfig.insert(ProtocolProps::protoToString(p), protoConfig);
+    }
+
+    QJsonObject config = m_settings->server(serverIndex);
+    if (!e) {
+        config.remove(config_key::userName);
+        config.remove(config_key::password);
+        config.remove(config_key::port);
+        config.insert(config_key::containers, QJsonArray{containerConfig});
+        config.insert(config_key::defaultContainer, ContainerProps::containerToString(container));
+
+        auto dns = m_configurator->getDnsForConfig(serverIndex);
+        config.insert(config_key::dns1, dns.first);
+        config.insert(config_key::dns2, dns.second);
+
+    } /*else {
+        set_textEditShareAmneziaCodeText(tr("Error while generating connection profile"));
+        return;
+    }*/
+    QByteArray compressedConfig = QJsonDocument(config).toJson();
+    compressedConfig = qCompress(compressedConfig, 8);
+    m_amneziaCode = QString("vpn://%1")
+                        .arg(QString(compressedConfig.toBase64(QByteArray::Base64UrlEncoding
+                                                               | QByteArray::OmitTrailingEquals)));
+
+    m_qrCodes = generateQrCodeImageSeries(compressedConfig);
+}
+
+QString ExportController::getAmneziaCode()
+{
+    return m_amneziaCode;
+}
+
+QList<QString> ExportController::getQrCodes()
+{
+    return m_qrCodes;
+}
+
+void ExportController::saveFile()
+{
+    QString fileExtension = ".vpn";
+    QString docDir = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
+    QUrl fileName;
+    fileName = QFileDialog::getSaveFileUrl(nullptr,
+                                           tr("Save AmneziaVPN config"),
+                                           QUrl::fromLocalFile(docDir + "/" + "amnezia_config"),
+                                           "*" + fileExtension);
+    if (fileName.isEmpty())
+        return;
+    if (!fileName.toString().endsWith(fileExtension)) {
+        fileName = QUrl(fileName.toString() + fileExtension);
+    }
+    if (fileName.isEmpty())
+        return;
+
+    QFile save(fileName.toLocalFile());
+
+    save.open(QIODevice::WriteOnly);
+    save.write(m_amneziaCode.toUtf8());
+    save.close();
+
+    QFileInfo fi(fileName.toLocalFile());
+    QDesktopServices::openUrl(fi.absoluteDir().absolutePath());
+}
+
+QList<QString> ExportController::generateQrCodeImageSeries(const QByteArray &data)
+{
+    double k = 850;
+
+    quint8 chunksCount = std::ceil(data.size() / k);
+    QList<QString> chunks;
+    for (int i = 0; i < data.size(); i = i + k) {
+        QByteArray chunk;
+        QDataStream s(&chunk, QIODevice::WriteOnly);
+        s << amnezia::qrMagicCode << chunksCount << (quint8) std::round(i / k) << data.mid(i, k);
+
+        QByteArray ba = chunk.toBase64(QByteArray::Base64UrlEncoding
+                                       | QByteArray::OmitTrailingEquals);
+
+        qrcodegen::QrCode qr = qrcodegen::QrCode::encodeText(ba, qrcodegen::QrCode::Ecc::LOW);
+        QString svg = QString::fromStdString(toSvgString(qr, 0));
+        chunks.append(svgToBase64(svg));
+    }
+
+    return chunks;
+}
+
+QString ExportController::svgToBase64(const QString &image)
+{
+    return "data:image/svg;base64," + QString::fromLatin1(image.toUtf8().toBase64().data());
+}

client/ui/controllers/exportController.h

@@ -0,0 +1,44 @@
+#ifndef EXPORTCONTROLLER_H
+#define EXPORTCONTROLLER_H
+
+#include <QObject>
+
+#include "configurators/vpn_configurator.h"
+#include "ui/models/containers_model.h"
+#include "ui/models/servers_model.h"
+
+class ExportController : public QObject
+{
+    Q_OBJECT
+public:
+    explicit ExportController(const QSharedPointer<ServersModel> &serversModel,
+                              const QSharedPointer<ContainersModel> &containersModel,
+                              const std::shared_ptr<Settings> &settings,
+                              const std::shared_ptr<VpnConfigurator> &configurator,
+                              QObject *parent = nullptr);
+
+public slots:
+    void generateFullAccessConfig();
+    void generateConnectionConfig();
+    QString getAmneziaCode();
+    QList<QString> getQrCodes();
+
+    void saveFile();
+
+signals:
+    void generateConfig(bool isFullAccess);
+
+private:
+    QList<QString> generateQrCodeImageSeries(const QByteArray &data);
+    QString svgToBase64(const QString &image);
+
+    QSharedPointer<ServersModel> m_serversModel;
+    QSharedPointer<ContainersModel> m_containersModel;
+    std::shared_ptr<Settings> m_settings;
+    std::shared_ptr<VpnConfigurator> m_configurator;
+
+    QString m_amneziaCode;
+    QList<QString> m_qrCodes;
+};
+
+#endif // EXPORTCONTROLLER_H

client/ui/controllers/importController.h

@@ -27,6 +27,7 @@ public slots:
 signals:
     void importFinished();
     void importErrorOccurred(QString errorMessage);
+
 private:
     QJsonObject extractAmneziaConfig(QString &data);
     QJsonObject extractOpenVpnConfig(const QString &data);

client/ui/controllers/installController.cpp

@@ -9,8 +9,7 @@ InstallController::InstallController(const QSharedPointer<ServersModel> &servers
                                     const QSharedPointer<ContainersModel> &containersModel,
                                     const std::shared_ptr<Settings> &settings,
                                     QObject *parent) : QObject(parent), m_serversModel(serversModel), m_containersModel(containersModel),  m_settings(settings)
-{
-}
+{}
 
 void InstallController::install(DockerContainer container, int port, TransportProto transportProto)
 {

client/ui/controllers/pageController.h

@@ -24,7 +24,6 @@ namespace PageLoader
         PageSettingsServerProtocol,
 
         PageSetupWizardStart,
-        PageTest,
         PageSetupWizardCredentials,
         PageSetupWizardProtocols,
         PageSetupWizardEasy,

client/ui/controllers/protocolSettingsController.cpp

@@ -0,0 +1,19 @@
+#include "protocolSettingsController.h"
+
+ProtocolSettingsController::ProtocolSettingsController(
+    const QSharedPointer<ServersModel> &serversModel,
+    const QSharedPointer<ContainersModel> &containersModel,
+    const std::shared_ptr<Settings> &settings,
+    QObject *parent)
+    : QObject(parent)
+    , m_serversModel(serversModel)
+    , m_containersModel(containersModel)
+    , m_settings(settings)
+{}
+
+QByteArray ProtocolSettingsController::getOpenVpnConfig()
+{
+    auto containerIndex = m_containersModel->index(
+        m_containersModel->getCurrentlyProcessedContainerIndex());
+    auto config = m_containersModel->data(containerIndex, ContainersModel::Roles::ConfigRole);
+}

client/ui/controllers/protocolSettingsController.h

@@ -0,0 +1,31 @@
+#ifndef PROTOCOLSETTINGSCONTROLLER_H
+#define PROTOCOLSETTINGSCONTROLLER_H
+
+#include <QObject>
+
+#include "containers/containers_defs.h"
+#include "core/defs.h"
+#include "ui/models/containers_model.h"
+#include "ui/models/servers_model.h"
+
+class ProtocolSettingsController : public QObject
+{
+    Q_OBJECT
+public:
+    explicit ProtocolSettingsController(const QSharedPointer<ServersModel> &serversModel,
+                                        const QSharedPointer<ContainersModel> &containersModel,
+                                        const std::shared_ptr<Settings> &settings,
+                                        QObject *parent = nullptr);
+
+public slots:
+    QByteArray getOpenVpnConfig();
+
+signals:
+
+private:
+    QSharedPointer<ServersModel> m_serversModel;
+    QSharedPointer<ContainersModel> m_containersModel;
+    std::shared_ptr<Settings> m_settings;
+};
+
+#endif // PROTOCOLSETTINGSCONTROLLER_H