diff --git a/.gitignore b/.gitignore
index 9ea395f15ee8cd2ff5fbb1c8f5aee55efd5636f6..3536a797ffbb003ddb8ced9f6087c195e175905f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,9 +1,2 @@
-CMakeCache.txt
-CMakeFiles
-CMakeScripts
-Testing
-Makefile
-cmake_install.cmake
-install_manifest.txt
-compile_commands.json
-CTestTestfile.cmake
+*.user*
+*~
diff --git a/KelvinDashboard.pro b/KelvinDashboard.pro
new file mode 100644
index 0000000000000000000000000000000000000000..6d654c848068c8aa655dd8e3e379d5a61938e498
--- /dev/null
+++ b/KelvinDashboard.pro
@@ -0,0 +1,12 @@
+TEMPLATE = subdirs
+SUBDIRS = KelvinDashboardGUI KelvinDashboardService
+
+KelvinDashboardGUI.subdir = KelvinDashboardGUI
+KelvinDashboardService.subdir = KelvinDashboardService
+KelvinDashboardGUI.depends = KelvinDashboardService
+
+!defined(BRAND, var)
+{
+ BRAND = KelvinDashboard
+}
+
diff --git a/KelvinDashboardGUI/DapClient.cpp b/KelvinDashboardGUI/DapClient.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7c3ba56efbfa66d3df08b04bb85bba5e1c5bd894
--- /dev/null
+++ b/KelvinDashboardGUI/DapClient.cpp
@@ -0,0 +1,156 @@
+#include "DapClient.h"
+
+/// Standard Ñonstructor.
+DapClient::DapClient(QObject *parent) : QObject(parent)
+{
+ connect(&m_localClient, &DapLocalClient::commandRecieved, this, &DapClient::identificationCommand);
+ connect(&m_localClient, static_cast<void(DapLocalClient::*)(DapLocalClient::LocalSocketError)>(&DapLocalClient::error), this, &DapClient::errorHandler);
+ connect(&m_localClient, &DapLocalClient::connected, this, [=]
+ {
+ QTimer::singleShot(1000, [&]
+ {
+ emit connectedToService();
+ });
+ });
+}
+
+/// Get an instance of a class.
+/// @return Instance of a class.
+DapClient &DapClient::getInstance()
+{
+ static DapClient instance;
+ return instance;
+}
+
+/// Connect to the service.
+/// @brief The name of the service connection is set from the NameSrvice property.
+void DapClient::connectToService()
+{
+ qDebug() << "Connect to service ()" << getNameSrvice();
+ m_localClient.connectToServer(getNameSrvice());
+}
+
+/// Connect to the service.
+/// @param nameService Service connection name.
+void DapClient::connectToService(const QString &nameService)
+{
+ setNameSrvice(nameService);
+ qDebug() << "Connect to servoce (nameService)";
+ m_localClient.connectToServer(nameService);
+}
+
+/// Authorize user.
+/// @param password User password.
+void DapClient::authorization(const QString &password)
+{
+ qDebug() << "Authorization " << password << endl;
+ DapCommand command(TypeDapCommand::Authorization, 1, { password });
+ m_localClient.sendCommand(command);
+}
+
+/// Handle connection error.
+/// @param socketError Error local connection of the client with the service.
+void DapClient::errorHandler(const DapLocalClient::LocalSocketError &socketError)
+{
+ switch (socketError) {
+ case DapLocalClient::PeerClosedError:
+ case DapLocalClient::ConnectionRefusedError:
+ case DapLocalClient::ServerNotFoundError:
+ QTimer::singleShot(1000, [&]
+ {
+ connectToService();
+ emit errorConnect();
+ } );
+ break;
+ default:
+ break;
+ }
+}
+
+/// Get the name of the service connection.
+/// @return The name of the service connection.
+QString DapClient::getNameSrvice() const
+{
+ return m_nameService;
+}
+
+/// Set the name of the service connection.
+/// @param nameService Service connection name.
+void DapClient::setNameSrvice(const QString &nameService)
+{
+ m_nameService = nameService;
+ m_localClient.setNameConnect(nameService);
+}
+
+/// Get company brand.
+/// @return Brand Ñompany.
+QString DapClient::getBrand() const
+{
+ return m_brand;
+}
+
+/// Get app version.
+/// @return Application version.
+QString DapClient::getVersion() const
+{
+ return m_version;
+}
+
+/// Get user authorization flag.
+/// @return Returns true if the user is authorized, otherwise - false.
+bool DapClient::getIsAuthorization() const
+{
+ return m_isAuthorization;
+}
+
+/// Set user authorization flag.
+/// @param isAuthorization The value of the user authorization flag.
+void DapClient::setIsAuthorization(bool isAuthorization)
+{
+ m_isAuthorization = isAuthorization;
+ emit isAuthorizationChanged(m_isAuthorization);
+}
+
+/// /// Identification of the command received.
+/// @param command Command received.
+/// @return Returns true if the command is identified, otherwise - false.
+bool DapClient::identificationCommand(const DapCommand &command)
+{
+ qDebug() << "Identification command: " << command.getTypeCommand();
+ qDebug() << "Identification command: " << command.getArguments().count();
+ switch (command.getTypeCommand())
+ {
+ case TypeDapCommand::Authorization:
+ if(command.getArgument(0).toBool())
+ setIsAuthorization(true);
+ else
+ setIsAuthorization(false);
+ return true;
+ case TypeDapCommand::ActivateWindowClient:
+ emit activateWindow();
+ return true;
+ case TypeDapCommand::CheckExistenceClient:
+ if(command.getArgument(0).toBool())
+ emit isExistenceClient(true);
+ else
+ emit isExistenceClient(false);
+ return true;
+ case TypeDapCommand::CloseClient:
+ qApp->quit();
+ return true;
+ default:
+ return false;
+ }
+}
+
+/// Method that implements the singleton pattern for the qml layer.
+/// @param engine QML application.
+/// @param scriptEngine The QJSEngine class provides an environment for evaluating JavaScript code.
+QObject *DapClient::singletonProvider(QQmlEngine *engine, QJSEngine *scriptEngine)
+{
+ Q_UNUSED(engine)
+ Q_UNUSED(scriptEngine)
+
+ return &getInstance();
+}
+
diff --git a/KelvinDashboardGUI/DapClient.h b/KelvinDashboardGUI/DapClient.h
new file mode 100644
index 0000000000000000000000000000000000000000..d0801e72fc63c511a997c607d82f18541c5b4a4e
--- /dev/null
+++ b/KelvinDashboardGUI/DapClient.h
@@ -0,0 +1,131 @@
+/****************************************************************************
+**
+** This file is part of the KelvinDashboardGUI application.
+**
+** The class implements the GUI interface of the application. Designed to
+** broadcast user actions to the service. Manages the state of graphic
+** elements of the GUI framework, connection with the service, identification
+** of commands received from the service, etc.
+**
+** Class implements a singleton pattern.
+**
+****************************************************************************/
+
+#ifndef DAPCLIENT_H
+#define DAPCLIENT_H
+
+#include <QObject>
+#include <QLocalSocket>
+#include <QQmlEngine>
+#include <QJSEngine>
+#include <QApplication>
+#include <QTimer>
+
+#include "DapCommand.h"
+#include "DapLocalClient.h"
+
+class DapClient : public QObject
+{
+ Q_OBJECT
+
+ /// Local client.
+ DapLocalClient m_localClient;
+ /// Brand Ñompany.
+ QString m_brand {DAP_BRAND};
+ /// Application version.
+ QString m_version {DAP_VERSION};
+ /// Service connection name.
+ QString m_nameService;
+ /// User authorization flag.
+ bool m_isAuthorization {false};
+
+ /// Standard Ñonstructor.
+ explicit DapClient(QObject *parent = nullptr);
+public:
+ DapClient(const DapClient&) = delete;
+ DapClient& operator= (const DapClient &) = delete;
+
+ /// Get an instance of a class.
+ /// @return Instance of a class.
+ Q_INVOKABLE static DapClient &getInstance();
+
+ ///********************************************
+ /// Property
+ /// *******************************************
+
+ /// Service connection name.
+ Q_PROPERTY(QString NameSrvice MEMBER m_nameService READ getNameSrvice WRITE setNameSrvice NOTIFY nameSrviceChanged)
+ /// Brand Ñompany.
+ Q_PROPERTY(QString Brand MEMBER m_brand READ getBrand NOTIFY brandChanged)
+ /// Application version.
+ Q_PROPERTY(QString Version MEMBER m_version READ getVersion NOTIFY versionChanged)
+ /// User authorization flag.
+ Q_PROPERTY(bool IsAuthorization MEMBER m_isAuthorization READ getIsAuthorization WRITE setIsAuthorization NOTIFY isAuthorizationChanged)
+
+ ///********************************************
+ /// Interface
+ /// *******************************************
+
+ /// Connect to the service.
+ /// @brief The name of the service connection is set from the NameSrvice property.
+ Q_INVOKABLE void connectToService();
+ /// Connect to the service.
+ /// @param nameService Service connection name.
+ Q_INVOKABLE void connectToService(const QString &nameService);
+ /// Authorize user.
+ /// @param password User password.
+ Q_INVOKABLE void authorization(const QString &password);
+ /// Handle connection error.
+ /// @param socketError Error local connection of the client with the service.
+ void errorHandler(const QLocalSocket::LocalSocketError& socketError);
+ /// Get the name of the service connection.
+ /// @return The name of the service connection.
+ QString getNameSrvice() const;
+ /// Set the name of the service connection.
+ /// @param nameService Service connection name.
+ void setNameSrvice(const QString &nameService);
+ /// Get company brand.
+ /// @return Brand Ñompany.
+ QString getBrand() const;
+ /// Get app version.
+ /// @return Application version.
+ QString getVersion() const;
+ /// Get user authorization flag.
+ /// @return Returns true if the user is authorized, otherwise - false.
+ bool getIsAuthorization() const;
+ /// Set user authorization flag.
+ /// @param isAuthorization The value of the user authorization flag.
+ void setIsAuthorization(bool isAuthorization);
+
+signals:
+ /// The signal is emitted when a successful connection to the service is established.
+ void connectedToService();
+ /// The signal is emitted when the connection to the service is broken.
+ void disconnectedFromService();
+ /// The signal is emitted when the name of the client's connection with the service is changed.
+ void nameSrviceChanged(const QString &nameService);
+ /// The signal is emitted when the Brand company property changes.
+ void brandChanged(const QString &brand);
+ /// The signal is emitted when the Application version property changes.
+ void versionChanged(const QString &version);
+ /// The signal is emitted when the User authorization flag property changes.
+ void isAuthorizationChanged(bool isAuthorization);
+ /// The signal is emitted when the main application window is activated.
+ void activateWindow();
+ /// The signal is emitted when an error occurs in the connection between the client and the service.
+ void errorConnect();
+ /// The signal is emitted when checking the existence of an already running copy of the application.
+ void isExistenceClient(bool isExistenceClient);
+
+public slots:
+ /// /// Identification of the command received.
+ /// @param command Command received.
+ /// @return Returns true if the command is identified, otherwise - false.
+ bool identificationCommand(const DapCommand &command);
+ /// Method that implements the singleton pattern for the qml layer.
+ /// @param engine QML application.
+ /// @param scriptEngine The QJSEngine class provides an environment for evaluating JavaScript code.
+ static QObject *singletonProvider(QQmlEngine *engine, QJSEngine *scriptEngine);
+};
+
+#endif // DAPCLIENT_H
diff --git a/KelvinDashboardGUI/DapQmlScreenAbout.qml b/KelvinDashboardGUI/DapQmlScreenAbout.qml
new file mode 100644
index 0000000000000000000000000000000000000000..0d2c3fd75d224dabdc62f7bb420346508d4e1670
--- /dev/null
+++ b/KelvinDashboardGUI/DapQmlScreenAbout.qml
@@ -0,0 +1,13 @@
+import QtQuick 2.9
+import QtQml 2.11
+import QtQuick.Controls 2.2
+import KelvinDashboard 1.0
+
+DapUiQmlScreenAbout {
+ id: dapQmlScreenAbout
+
+ textTitle.text: DapClient.Brand
+ textAbout.text: "KelvinDashboard"
+ textVersion.text: "Version " + DapClient.Version
+ textYear.text: new Date().toLocaleDateString(locale, "dd MMM yyyy")
+}
diff --git a/KelvinDashboardGUI/DapQmlScreenLogin.qml b/KelvinDashboardGUI/DapQmlScreenLogin.qml
new file mode 100644
index 0000000000000000000000000000000000000000..cb6c8469fa01f669515f3c1e09a68aefd88d9c7f
--- /dev/null
+++ b/KelvinDashboardGUI/DapQmlScreenLogin.qml
@@ -0,0 +1,36 @@
+import QtQuick 2.0
+import KelvinDashboard 1.0
+
+DapUiQmlScreenLogin {
+ id: dapQmlScreenLogin
+
+ function acceptPassword()
+ {
+ dapScreenLogin.Password = textFieldPassword.text
+ DapClient.authorization(textFieldPassword.text)
+ console.log(textFieldPassword.text)
+ }
+
+ Connections {
+ target: dapClient
+
+ onIsAuthorizationChanged: {
+ console.log("PARAM " + isAuthorization)
+ textStatus.visible = true
+ if(isAuthorization)
+ {
+ textStatus.text = "Password confirmed"
+ textStatus.color = "green"
+ textFieldPassword.color = "green"
+ }
+ else
+ {
+ textStatus.text = "Password not verified"
+ textStatus.color = "red"
+ textFieldPassword.color = "red"
+ }
+ }
+ }
+
+ buttonPassword.onClicked: acceptPassword()
+}
diff --git a/KelvinDashboardGUI/DapScreenDialog.h b/KelvinDashboardGUI/DapScreenDialog.h
new file mode 100644
index 0000000000000000000000000000000000000000..c3a5028c8c1f0b82f82674fbbdfdcf1f77a0a0c3
--- /dev/null
+++ b/KelvinDashboardGUI/DapScreenDialog.h
@@ -0,0 +1,11 @@
+#ifndef DAPUIQMLSCREENDIALOG_H
+#define DAPUIQMLSCREENDIALOG_H
+
+
+class DapUiQmlScreenDialog
+{
+public:
+ DapUiQmlScreenDialog();
+};
+
+#endif // DAPUIQMLSCREENDIALOG_H
diff --git a/KelvinDashboardGUI/DapScreenLogin.cpp b/KelvinDashboardGUI/DapScreenLogin.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9c1fe7ec90d6c51dcafe53ad330ff7418f869d98
--- /dev/null
+++ b/KelvinDashboardGUI/DapScreenLogin.cpp
@@ -0,0 +1,22 @@
+#include "DapScreenLogin.h"
+
+DapScreenLogin::DapScreenLogin(QObject *parent) : QObject(parent)
+{
+ connect(this, &DapScreenLogin::passwordChanged, this, &DapScreenLogin::autorization);
+}
+
+QString DapScreenLogin::getPassword() const
+{
+ return m_password;
+}
+
+void DapScreenLogin::setPassword(const QString &password)
+{
+ qDebug() << "Set password: " << password << endl;
+ m_password = password;
+}
+
+bool DapScreenLogin::autorization(const QString &password)
+{
+
+}
diff --git a/KelvinDashboardGUI/DapScreenLogin.h b/KelvinDashboardGUI/DapScreenLogin.h
new file mode 100644
index 0000000000000000000000000000000000000000..8debb16252e5b6792fb4fb17dc54671b659d07b6
--- /dev/null
+++ b/KelvinDashboardGUI/DapScreenLogin.h
@@ -0,0 +1,28 @@
+#ifndef DAPSCREENLOGIN_H
+#define DAPSCREENLOGIN_H
+
+#include <QObject>
+#include <QDebug>
+
+class DapScreenLogin : public QObject
+{
+ Q_OBJECT
+
+ QString m_password;
+public:
+ explicit DapScreenLogin(QObject *parent = nullptr);
+
+ Q_PROPERTY(QString Password MEMBER m_password READ getPassword WRITE setPassword NOTIFY passwordChanged)
+
+ QString getPassword() const;
+
+ void setPassword(const QString &password);
+
+ Q_INVOKABLE bool autorization(const QString& password);
+signals:
+
+ void passwordChanged(const QString& password);
+public slots:
+};
+
+#endif // DAPSCREENLOGIN_H
diff --git a/KelvinDashboardGUI/DapUiQmlListModelWidgets.qml b/KelvinDashboardGUI/DapUiQmlListModelWidgets.qml
new file mode 100644
index 0000000000000000000000000000000000000000..c97243ad31ec076f6d006354bdcb7e0f5e85eca5
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlListModelWidgets.qml
@@ -0,0 +1,30 @@
+import QtQuick 2.0
+
+ListModel {
+ id: listModelMenu
+
+ ListElement {
+ name: qsTr("Blockchain explorer")
+ page: "DapUiQmlWidgetChainBlockExplorer.ui.qml"
+ }
+ ListElement {
+ name: qsTr("Exchanges")
+ page: "DapUiQmlWidgetChainExchanges.ui.qml"
+ }
+ ListElement {
+ name: qsTr("Services client")
+ page: "DapUiQmlWidgetChainServicesClient.ui.qml"
+ }
+ ListElement {
+ name: qsTr("Services share control")
+ page: "DapUiQmlWidgetChainServicesShareControl.ui.qml"
+ }
+ ListElement {
+ name: qsTr("Settings")
+ page: "DapUiQmlWidgetChainSettings.ui.qml"
+ }
+ ListElement {
+ name: qsTr("Wallet")
+ page: "DapUiQmlWidgetChainWallet.ui.qml"
+ }
+}
diff --git a/KelvinDashboardGUI/DapUiQmlScreenAbout.ui.qml b/KelvinDashboardGUI/DapUiQmlScreenAbout.ui.qml
new file mode 100644
index 0000000000000000000000000000000000000000..55b664fa6c7cfd88ba2ee43a1e3c7eb17299ba42
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlScreenAbout.ui.qml
@@ -0,0 +1,77 @@
+import QtQuick 2.9
+import QtQuick.Controls 2.2
+import QtQuick.Layouts 1.1
+
+Page {
+ id: dapUiQmlScreenAbout
+
+ property alias textTitle: textTitle
+ property alias textAbout: textAbout
+ property alias textVersion: textVersion
+ property alias textYear: textYear
+
+ title: qsTr("About")
+
+ ColumnLayout {
+ id: columnScreenLogin
+ width: parent.width
+ anchors.centerIn: parent
+ clip: true
+
+ RowLayout {
+ id: rowAboutInformation
+ spacing: 15
+ Layout.alignment: Qt.AlignHCenter
+ Layout.bottomMargin: 20
+
+ Image {
+ id: name
+ source: "qrc:/Resources/Icons/icon.png"
+ scale: 2
+ Layout.alignment: Qt.AlignHCenter
+ }
+
+ ColumnLayout {
+ id: columnText
+
+ Text {
+ id: textTitle
+ width: parent.width
+ font.pointSize: 14
+ font.bold: true
+ wrapMode: Text.WordWrap
+ horizontalAlignment: Text.AlignHCenter
+ Layout.alignment: Qt.AlignHCenter
+ }
+
+ Text {
+ id: textAbout
+ width: parent.width
+ font.pointSize: 12
+ wrapMode: Text.WordWrap
+ horizontalAlignment: Text.AlignHCenter
+ Layout.alignment: Qt.AlignHCenter
+ }
+ }
+ }
+
+ Text {
+ id: textVersion
+ width: parent.width
+ font.pointSize: 10
+ wrapMode: Text.WordWrap
+ horizontalAlignment: Text.AlignHCenter
+ Layout.alignment: Qt.AlignHCenter
+ }
+
+ Text {
+ id: textYear
+ width: parent.width
+ font.pointSize: 10
+ wrapMode: Text.WordWrap
+ horizontalAlignment: Text.AlignHCenter
+ Layout.alignment: Qt.AlignHCenter
+ }
+ }
+
+}
diff --git a/KelvinDashboardGUI/DapUiQmlScreenDashboard.cpp b/KelvinDashboardGUI/DapUiQmlScreenDashboard.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ea06dd6231bea21f54cd8fcab6330af89513af25
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlScreenDashboard.cpp
@@ -0,0 +1,6 @@
+#include "DapUiQmlScreenDashboard.h"
+
+DapUiQmlScreenDashboard::DapUiQmlScreenDashboard()
+{
+
+}
diff --git a/KelvinDashboardGUI/DapUiQmlScreenDashboard.h b/KelvinDashboardGUI/DapUiQmlScreenDashboard.h
new file mode 100644
index 0000000000000000000000000000000000000000..1417dcb673466a1f62c6d5663d79f3bfdec3c939
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlScreenDashboard.h
@@ -0,0 +1,11 @@
+#ifndef DAPUIQMLSCREENDASHBOARD_H
+#define DAPUIQMLSCREENDASHBOARD_H
+
+
+class DapUiQmlScreenDashboard
+{
+public:
+ DapUiQmlScreenDashboard();
+};
+
+#endif // DAPUIQMLSCREENDASHBOARD_H
\ No newline at end of file
diff --git a/KelvinDashboardGUI/DapUiQmlScreenDashboard.qml b/KelvinDashboardGUI/DapUiQmlScreenDashboard.qml
new file mode 100644
index 0000000000000000000000000000000000000000..f4963d3b99554539cba7d87cf964a0efc38301ba
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlScreenDashboard.qml
@@ -0,0 +1,86 @@
+import QtQuick 2.9
+import QtQuick.Controls 1.4
+import QtQuick.Controls 2.2
+import QtQuick.Controls.Styles 1.4
+
+Page {
+ id: dapUiQmlScreenDashboard
+ title: qsTr("General")
+ ListView {
+ id: listViewTabs
+ anchors.top: parent.top
+ anchors.bottom: parent.bottom
+ anchors.left: parent.left
+ width: dapUiQmlScreenDashboard.width/5
+ model: listModelTabs
+
+ ListModel {
+ id: listModelTabs
+
+ ListElement {
+ name: qsTr("Login")
+ page: "DapQmlScreenLogin.qml"
+ }
+ ListElement {
+ name: qsTr("Dashboard")
+ page: "DapUiQmlScreenDialog.qml"
+ }
+ ListElement {
+ name: qsTr("About")
+ page: "DapQmlScreenAbout.qml"
+ }
+ }
+
+
+
+ delegate:
+ Component {
+ id: componentTab
+ Item {
+ width: listViewTabs.width
+ height: textTab.height + 10
+ Rectangle {
+ id: canvas
+ border.color: "whitesmoke"
+ color: "Transparent"
+ anchors.fill: parent
+ Row {
+ anchors.margins: 5
+ anchors.fill: parent
+
+ Text
+ {
+ id: textTab
+ text: qsTr(name)
+ }
+ }
+ }
+
+ MouseArea {
+ anchors.fill: parent
+ onClicked:
+ {
+ listViewTabs.currentIndex = index
+ stackViewScreenDashboard.setSource(Qt.resolvedUrl(page))
+ }
+ }
+ }
+ }
+
+ highlight: Rectangle { color: "aliceblue"; radius: 1 }
+ focus: true
+ }
+ Rectangle {
+ anchors.left: listViewTabs.right
+ anchors.top: parent.top
+ anchors.bottom: parent.bottom
+ anchors.right: parent.right
+ border.color: "whitesmoke"
+ Loader {
+ id: stackViewScreenDashboard
+ anchors.fill: parent
+ anchors.margins: 1
+ source: "DapQmlScreenLogin.qml"
+ }
+ }
+}
diff --git a/KelvinDashboardGUI/DapUiQmlScreenDialog.cpp b/KelvinDashboardGUI/DapUiQmlScreenDialog.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5621b7849fdbf5c54c4a69d7ebf0dcb4ed74ae48
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlScreenDialog.cpp
@@ -0,0 +1,6 @@
+#include "DapScreenDialog.h"
+
+DapUiQmlScreenDialog::DapUiQmlScreenDialog()
+{
+
+}
diff --git a/KelvinDashboardGUI/DapUiQmlScreenDialog.qml b/KelvinDashboardGUI/DapUiQmlScreenDialog.qml
new file mode 100644
index 0000000000000000000000000000000000000000..a6d222603c18deecc4e0a3b567d185798c59ddb9
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlScreenDialog.qml
@@ -0,0 +1,63 @@
+import QtQuick 2.9
+import QtQuick.Controls 2.4
+
+Page {
+ id: dapUiQmlScreenDialog
+ title: qsTr("Dashboard")
+ anchors.fill: parent
+
+ Rectangle {
+ color: "white"
+ anchors.fill: parent
+
+ GridView {
+ id: gridViewDashboard
+ anchors.fill: parent
+ cellWidth: width/3; cellHeight: height/2
+ focus: true
+ model: DapUiQmlListModelWidgets {}
+
+ highlight: Rectangle { width: gridViewDashboard.cellWidth; height: gridViewDashboard.cellHeight; radius: width/50; color: "aliceblue" }
+
+ delegate: Item {
+ width: gridViewDashboard.cellWidth
+ height: gridViewDashboard.cellHeight
+ Rectangle {
+ anchors.fill: parent
+ border.color: "grey"
+ color: "transparent"
+ radius: width/50
+ anchors.margins: 5
+ clip: true
+
+ Column {
+ width: parent.width
+ anchors.centerIn: parent
+ spacing: width / 10
+ anchors.margins: width / 10
+ Image {
+ id: iconWidget
+ source: "qrc:/Resources/Icons/add.png"
+ width: parent.width * 2/3
+ height: width
+ anchors.horizontalCenter: parent.horizontalCenter
+ }
+ Text {
+ text: name
+ color: "darkgrey"
+ anchors.horizontalCenter: parent.horizontalCenter
+ }
+ }
+ }
+ MouseArea {
+ anchors.fill: parent
+ onClicked:
+ {
+ parent.GridView.view.currentIndex = index;
+ stackView.push(Qt.resolvedUrl(page), StackView.Immediate);
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/KelvinDashboardGUI/DapUiQmlScreenLogin.cpp.autosave b/KelvinDashboardGUI/DapUiQmlScreenLogin.cpp.autosave
new file mode 100644
index 0000000000000000000000000000000000000000..e2737face41be9339d81b9ff9adb82c2ac4cfb95
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlScreenLogin.cpp.autosave
@@ -0,0 +1,16 @@
+#include "DapUiQmlScreenLogin.h"
+
+DapUiQmlScreenLogin::DapUiQmlScreenLogin(QObject *parent) : QObject(parent)
+{
+
+}
+
+QString DapUiQmlScreenLogin::getPassword() const
+{
+
+}
+
+void DapUiQmlScreenLogin::setPassword(const QString &password)
+{
+
+}
diff --git a/KelvinDashboardGUI/DapUiQmlScreenLogin.h.autosave b/KelvinDashboardGUI/DapUiQmlScreenLogin.h.autosave
new file mode 100644
index 0000000000000000000000000000000000000000..de225a2d0e4202a4e4781a64881d35529c16419a
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlScreenLogin.h.autosave
@@ -0,0 +1,25 @@
+#ifndef DAPUIQMLSCREENLOGIN_H
+#define DAPUIQMLSCREENLOGIN_H
+
+#include <QObject>
+
+class DapUiQmlScreenLogin : public QObject
+{
+ Q_OBJECT
+
+ QString m_password;
+public:
+ explicit DapUiQmlScreenLogin(QObject *parent = nullptr);
+
+ Q_PROPERTY(QString Password MEMBER m_password READ Password WRITE setPassword NOTIFY passwordChanged)
+
+ QString getPassword() const;
+
+ void setPassword(const QString &password);
+signals:
+
+ void passwordChanged(const QString& password);
+public slots:
+};
+
+#endif // DAPUIQMLSCREENLOGIN_H
\ No newline at end of file
diff --git a/KelvinDashboardGUI/DapUiQmlScreenLogin.ui.qml b/KelvinDashboardGUI/DapUiQmlScreenLogin.ui.qml
new file mode 100644
index 0000000000000000000000000000000000000000..3e03cb113f0476f1f7dce744bb4fb19a68c0de20
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlScreenLogin.ui.qml
@@ -0,0 +1,52 @@
+import QtQuick 2.9
+import QtQuick.Controls 2.2
+import KelvinDashboard 1.0
+
+Page {
+ id: dapUiQmlScreenLogin
+
+ property alias dapScreenLogin: dapScreenLogin
+ property alias textFieldPassword: textFieldPassword
+ property alias buttonPassword: buttonPassword
+ property alias textStatus: textStatus
+
+ title: qsTr("Login")
+
+ DapScreenLogin
+ {
+ id: dapScreenLogin
+ }
+
+ Column {
+ id: columnScreenLogin
+ width: parent.width
+ anchors.centerIn: parent
+ spacing: 10
+ clip: true
+
+ TextField {
+ id: textFieldPassword
+ placeholderText: "Password"
+ echoMode: TextInput.Password
+ anchors.horizontalCenter: parent.horizontalCenter
+ }
+
+ Text {
+ id: textStatus
+ width: parent.width
+ wrapMode: Text.WordWrap
+ horizontalAlignment: Text.AlignHCenter
+ anchors.horizontalCenter: parent.horizontalCenter
+ visible: false
+ }
+
+ Button {
+ id: buttonPassword
+ text: "Log in"
+ width: textFieldPassword.width
+ anchors.horizontalCenter: parent.horizontalCenter
+ focus: true
+ }
+ }
+
+}
diff --git a/KelvinDashboardGUI/DapUiQmlScreenMainWindow.ui.qml b/KelvinDashboardGUI/DapUiQmlScreenMainWindow.ui.qml
new file mode 100644
index 0000000000000000000000000000000000000000..edc520024fe0c426c223257aabc8d72763a3dc28
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlScreenMainWindow.ui.qml
@@ -0,0 +1,8 @@
+import QtQuick 2.9
+import QtQuick.Controls 1.4
+import QtQuick.Controls 2.4
+
+Page {
+
+ title: qsTr("General")
+}
diff --git a/KelvinDashboardGUI/DapUiQmlWidget.cpp b/KelvinDashboardGUI/DapUiQmlWidget.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..59598aa4c5a19e72e3b861108185800ed5c57aa5
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlWidget.cpp
@@ -0,0 +1,6 @@
+#include "DapUiQmlWidget.h"
+
+DapUiQmlWidget::DapUiQmlWidget()
+{
+
+}
diff --git a/KelvinDashboardGUI/DapUiQmlWidget.h b/KelvinDashboardGUI/DapUiQmlWidget.h
new file mode 100644
index 0000000000000000000000000000000000000000..06ebafdc6182a1d48bfc9c9b6202a5e281ed6de8
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlWidget.h
@@ -0,0 +1,11 @@
+#ifndef DAPUIQMLWIDGET_H
+#define DAPUIQMLWIDGET_H
+
+
+class DapUiQmlWidget
+{
+public:
+ DapUiQmlWidget();
+};
+
+#endif // DAPUIQMLWIDGET_H
\ No newline at end of file
diff --git a/KelvinDashboardGUI/DapUiQmlWidgetChainBallance.cpp b/KelvinDashboardGUI/DapUiQmlWidgetChainBallance.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..68da31745da72d965fa4cd3bce1b461968246a83
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlWidgetChainBallance.cpp
@@ -0,0 +1,6 @@
+#include "DapUiQmlWidgetChainBallance.h"
+
+DapUiQmlWidgetChainBallance::DapUiQmlWidgetChainBallance()
+{
+
+}
diff --git a/KelvinDashboardGUI/DapUiQmlWidgetChainBallance.h b/KelvinDashboardGUI/DapUiQmlWidgetChainBallance.h
new file mode 100644
index 0000000000000000000000000000000000000000..be7239552f011864e4c2ef5ecb6b74e9cc257da9
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlWidgetChainBallance.h
@@ -0,0 +1,12 @@
+#ifndef DAPUIQMLWIDGETCHAINBALLANCE_H
+#define DAPUIQMLWIDGETCHAINBALLANCE_H
+
+#include "DapUiQmlWidget.h"
+
+class DapUiQmlWidgetChainBallance : public DapUiQmlWidget
+{
+public:
+ DapUiQmlWidgetChainBallance();
+};
+
+#endif // DAPUIQMLWIDGETCHAINBALLANCE_H
diff --git a/KelvinDashboardGUI/DapUiQmlWidgetChainBlockExplorer.cpp b/KelvinDashboardGUI/DapUiQmlWidgetChainBlockExplorer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..28ce99bd360f5a368f4cbef43a65fa945b9b4c56
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlWidgetChainBlockExplorer.cpp
@@ -0,0 +1,6 @@
+#include "DapUiQmlWidgetChainBlockExplorer.h"
+
+DapUiQmlWidgetChainBlockExplorer::DapUiQmlWidgetChainBlockExplorer()
+{
+
+}
diff --git a/KelvinDashboardGUI/DapUiQmlWidgetChainBlockExplorer.h b/KelvinDashboardGUI/DapUiQmlWidgetChainBlockExplorer.h
new file mode 100644
index 0000000000000000000000000000000000000000..dfcb58894dc748f019d925f59d88b7e4b9a55286
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlWidgetChainBlockExplorer.h
@@ -0,0 +1,12 @@
+#ifndef DAPUIQMLWIDGETCHAINBLOCKEXPLORER_H
+#define DAPUIQMLWIDGETCHAINBLOCKEXPLORER_H
+
+#include "DapUiQmlWidget.h"
+
+class DapUiQmlWidgetChainBlockExplorer : public DapUiQmlWidget
+{
+public:
+ DapUiQmlWidgetChainBlockExplorer();
+};
+
+#endif // DAPUIQMLWIDGETCHAINBLOCKEXPLORER_H
diff --git a/KelvinDashboardGUI/DapUiQmlWidgetChainBlockExplorer.ui.qml b/KelvinDashboardGUI/DapUiQmlWidgetChainBlockExplorer.ui.qml
new file mode 100644
index 0000000000000000000000000000000000000000..33225cc2eacc68742842b14aee75c6030ccf256b
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlWidgetChainBlockExplorer.ui.qml
@@ -0,0 +1,15 @@
+import QtQuick 2.9
+import QtQuick.Controls 2.2
+
+Page {
+ id: dapUiQmlWidgetChainBlockExplorer
+
+ title: qsTr("Blockchain explorer")
+
+ Text {
+ id: name
+ anchors.centerIn: parent
+ text: qsTr("Blockchain explorer")
+ }
+
+}
diff --git a/KelvinDashboardGUI/DapUiQmlWidgetChainExchanges.ui.qml b/KelvinDashboardGUI/DapUiQmlWidgetChainExchanges.ui.qml
new file mode 100644
index 0000000000000000000000000000000000000000..fef680a80689e2c520e8aea2af322b9a714b1b71
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlWidgetChainExchanges.ui.qml
@@ -0,0 +1,14 @@
+import QtQuick 2.9
+import QtQuick.Controls 2.2
+
+Page {
+ id: dapUiQmlWidgetChainExchanges
+
+ title: qsTr("Exchanges")
+
+ Text {
+ id: name
+ anchors.centerIn: parent
+ text: qsTr("Exchanges")
+ }
+}
diff --git a/KelvinDashboardGUI/DapUiQmlWidgetChainNodeLogs.cpp b/KelvinDashboardGUI/DapUiQmlWidgetChainNodeLogs.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..36ef984482f16eb614708b017e7c83d38d68a850
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlWidgetChainNodeLogs.cpp
@@ -0,0 +1,6 @@
+#include "DapUiQmlWidgetChainNodeLogs.h"
+
+DapUiQmlWidgetChainNodeLogs::DapUiQmlWidgetChainNodeLogs()
+{
+
+}
diff --git a/KelvinDashboardGUI/DapUiQmlWidgetChainNodeLogs.h b/KelvinDashboardGUI/DapUiQmlWidgetChainNodeLogs.h
new file mode 100644
index 0000000000000000000000000000000000000000..07123ebffdfde9cbfbad6995112402936ce5e188
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlWidgetChainNodeLogs.h
@@ -0,0 +1,12 @@
+#ifndef DAPUIQMLWIDGETCHAINNODELOGS_H
+#define DAPUIQMLWIDGETCHAINNODELOGS_H
+
+#include "DapUiQmlWidget.h"
+
+class DapUiQmlWidgetChainNodeLogs : public DapUiQmlWidget
+{
+public:
+ DapUiQmlWidgetChainNodeLogs();
+};
+
+#endif // DAPUIQMLWIDGETCHAINNODELOGS_H
diff --git a/KelvinDashboardGUI/DapUiQmlWidgetChainOperations.cpp b/KelvinDashboardGUI/DapUiQmlWidgetChainOperations.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2aff6130d0ed86da1c0f7742ab42a79eeb81c791
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlWidgetChainOperations.cpp
@@ -0,0 +1,6 @@
+#include "DapUiQmlWidgetChainOperations.h"
+
+DapUiQmlWidgeChainOperations::DapUiQmlWidgeChainOperations()
+{
+
+}
diff --git a/KelvinDashboardGUI/DapUiQmlWidgetChainOperations.h b/KelvinDashboardGUI/DapUiQmlWidgetChainOperations.h
new file mode 100644
index 0000000000000000000000000000000000000000..458778325c376405de920d752b0470aa3148de9d
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlWidgetChainOperations.h
@@ -0,0 +1,12 @@
+#ifndef DAPUIQMLWIDGECHAINOPERATIONS_H
+#define DAPUIQMLWIDGECHAINOPERATIONS_H
+
+#include "DapUiQmlWidget.h"
+
+class DapUiQmlWidgeChainOperations : public DapUiQmlWidget
+{
+public:
+ DapUiQmlWidgeChainOperations();
+};
+
+#endif // DAPUIQMLWIDGECHAINOPERATIONS_H
diff --git a/KelvinDashboardGUI/DapUiQmlWidgetChainServicesClient.ui.qml b/KelvinDashboardGUI/DapUiQmlWidgetChainServicesClient.ui.qml
new file mode 100644
index 0000000000000000000000000000000000000000..61065a0d44f5023cb061d719c59cf036cef79d23
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlWidgetChainServicesClient.ui.qml
@@ -0,0 +1,14 @@
+import QtQuick 2.9
+import QtQuick.Controls 2.2
+
+Page {
+ id: dapUiQmlWidgetChainServicesClient
+
+ title: qsTr("Services client")
+
+ Text {
+ id: name
+ anchors.centerIn: parent
+ text: qsTr("Services client")
+ }
+}
diff --git a/KelvinDashboardGUI/DapUiQmlWidgetChainServicesShareControl.ui.qml b/KelvinDashboardGUI/DapUiQmlWidgetChainServicesShareControl.ui.qml
new file mode 100644
index 0000000000000000000000000000000000000000..194f89e2ec45552e72ab39c7f89846a1c2e0e06b
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlWidgetChainServicesShareControl.ui.qml
@@ -0,0 +1,14 @@
+import QtQuick 2.9
+import QtQuick.Controls 2.2
+
+Page {
+ id: dapUiQmlWidgetChainServicesShareControl
+
+ title: qsTr("Services share control")
+
+ Text {
+ id: name
+ anchors.centerIn: parent
+ text: qsTr("Services share control")
+ }
+}
diff --git a/KelvinDashboardGUI/DapUiQmlWidgetChainSettings.ui.qml b/KelvinDashboardGUI/DapUiQmlWidgetChainSettings.ui.qml
new file mode 100644
index 0000000000000000000000000000000000000000..54d6ac5b4a03c2ebe6d3a3e8fdba3347e4800bf7
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlWidgetChainSettings.ui.qml
@@ -0,0 +1,14 @@
+import QtQuick 2.9
+import QtQuick.Controls 2.2
+
+Page {
+ id: dapUiQmlWidgetChainSettings
+
+ title: qsTr("Settings")
+
+ Text {
+ id: name
+ anchors.centerIn: parent
+ text: qsTr("Settings")
+ }
+}
diff --git a/KelvinDashboardGUI/DapUiQmlWidgetChainTransctions.cpp b/KelvinDashboardGUI/DapUiQmlWidgetChainTransctions.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..654f78de1a143a15b28efcca5628566d6ede75b4
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlWidgetChainTransctions.cpp
@@ -0,0 +1,6 @@
+#include "DapUiQmlWidgetChainTransctions.h"
+
+DapUiQmlWidgetChainTransctions::DapUiQmlWidgetChainTransctions()
+{
+
+}
diff --git a/KelvinDashboardGUI/DapUiQmlWidgetChainTransctions.h b/KelvinDashboardGUI/DapUiQmlWidgetChainTransctions.h
new file mode 100644
index 0000000000000000000000000000000000000000..2595d04e62de3aba2535b29b6dfa330adb3fc637
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlWidgetChainTransctions.h
@@ -0,0 +1,12 @@
+#ifndef DAPUIQMLWIDGETCHAINTRANSCTIONS_H
+#define DAPUIQMLWIDGETCHAINTRANSCTIONS_H
+
+#include "DapUiQmlWidget.h"
+
+class DapUiQmlWidgetChainTransctions : public DapUiQmlWidget
+{
+public:
+ DapUiQmlWidgetChainTransctions();
+};
+
+#endif // DAPUIQMLWIDGETCHAINTRANSCTIONS_H
diff --git a/KelvinDashboardGUI/DapUiQmlWidgetChainWallet.ui.qml b/KelvinDashboardGUI/DapUiQmlWidgetChainWallet.ui.qml
new file mode 100644
index 0000000000000000000000000000000000000000..465499b497235b5b058c80b1d46e28a589f29662
--- /dev/null
+++ b/KelvinDashboardGUI/DapUiQmlWidgetChainWallet.ui.qml
@@ -0,0 +1,14 @@
+import QtQuick 2.9
+import QtQuick.Controls 2.2
+
+Page {
+ id: dapUiQmlWidgetChainWallet
+
+ title: qsTr("Wallet")
+
+ Text {
+ id: name
+ anchors.centerIn: parent
+ text: qsTr("Wallet")
+ }
+}
diff --git a/KelvinDashboardGUI/KelvinDashboardGUI.conf b/KelvinDashboardGUI/KelvinDashboardGUI.conf
new file mode 100644
index 0000000000000000000000000000000000000000..75b2cb8fffb69c8cb04c1192f9425a11789972d0
--- /dev/null
+++ b/KelvinDashboardGUI/KelvinDashboardGUI.conf
@@ -0,0 +1,6 @@
+; This file can be edited to change the style of the application
+; Read "Qt Quick Controls 2 Configuration File" for details:
+; http://doc.qt.io/qt-5/qtquickcontrols2-configuration.html
+
+[Controls]
+Style=Default
diff --git a/KelvinDashboardGUI/KelvinDashboardGUI.pro b/KelvinDashboardGUI/KelvinDashboardGUI.pro
new file mode 100644
index 0000000000000000000000000000000000000000..df8eb7cede7e99568ad529b3cd569cd501539292
--- /dev/null
+++ b/KelvinDashboardGUI/KelvinDashboardGUI.pro
@@ -0,0 +1,77 @@
+QT += quick widgets quickwidgets
+
+TEMPLATE = app
+CONFIG += c++11
+
+
+!defined(BRAND,var){
+# Default brand
+ BRAND = KelvinDashboard
+}
+
+TARGET = $$BRAND
+
+VER_MAJ = 1
+VER_MIN = 0
+VER_PAT = 0
+
+
+win32 {
+ VERSION = $${VER_MAJ}.$${VER_MIN}.$$VER_PAT
+}
+else {
+ VERSION = $$VER_MAJ\.$$VER_MIN\-$$VER_PAT
+}
+
+# The following define makes your compiler emit warnings if you use
+# any feature of Qt which as been marked deprecated (the exact warnings
+# depend on your compiler). Please consult the documentation of the
+# deprecated API in order to know how to port your code away from it.
+DEFINES += QT_DEPRECATED_WARNINGS
+DEFINES += DAP_BRAND=\\\"$$BRAND\\\"
+DEFINES += DAP_VERSION=\\\"$$VERSION\\\"
+ICON = icon.ico
+# You can also make your code fail to compile if you use deprecated APIs.
+# In order to do so, uncomment the following line.
+# You can also select to disable deprecated APIs only up to a certain version of Qt.
+#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0
+
+SOURCES += \
+ main.cpp \
+ DapUiQmlWidget.cpp \
+ DapUiQmlWidgetChainBallance.cpp \
+ DapUiQmlScreenDialog.cpp \
+ DapUiQmlWidgetChainBlockExplorer.cpp \
+ DapUiQmlWidgetChainNodeLogs.cpp \
+ DapUiQmlWidgetChainTransctions.cpp \
+ DapUiQmlWidgetChainOperations.cpp \
+ DapScreenLogin.cpp \
+ DapClient.cpp
+
+RESOURCES += qml.qrc
+
+# Additional import path used to resolve QML modules in Qt Creator's code model
+QML_IMPORT_PATH =
+
+# Additional import path used to resolve QML modules just for Qt Quick Designer
+QML_DESIGNER_IMPORT_PATH =
+
+# Default rules for deployment.
+qnx: target.path = /tmp/$${TARGET}/bin
+else: unix:!android: target.path = /opt/$${TARGET}/bin
+!isEmpty(target.path): INSTALLS += target
+
+HEADERS += \
+ DapUiQmlWidget.h \
+ DapUiQmlWidgetChainBallance.h \
+ DapUiQmlWidgetChainBlockExplorer.h \
+ DapUiQmlWidgetChainNodeLogs.h \
+ DapUiQmlWidgetChainTransctions.h \
+ DapUiQmlScreenDashboard.h \
+ DapUiQmlWidgetChainOperations.h \
+ DapScreenDialog.h \
+ DapScreenLogin.h \
+ DapClient.h
+
+include (../libKelvinDashboardCommon/libKelvinDashboardCommon.pri)
+INCLUDEPATH += $$_PRO_FILE_PWD_/../libKelvinDashboardCommon/
diff --git a/KelvinDashboardGUI/Resources/Icons/add.png b/KelvinDashboardGUI/Resources/Icons/add.png
new file mode 100644
index 0000000000000000000000000000000000000000..f3c75ff7cc06fe9833492a80f6bd7ddcfefe3072
Binary files /dev/null and b/KelvinDashboardGUI/Resources/Icons/add.png differ
diff --git a/KelvinDashboardGUI/Resources/Icons/icon.ico b/KelvinDashboardGUI/Resources/Icons/icon.ico
new file mode 100644
index 0000000000000000000000000000000000000000..41230db92cb8101b8f24cf6f861082c6dfb827e1
Binary files /dev/null and b/KelvinDashboardGUI/Resources/Icons/icon.ico differ
diff --git a/KelvinDashboardGUI/Resources/Icons/icon.png b/KelvinDashboardGUI/Resources/Icons/icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..52525ef9e99b9d42242dcddc0f5f5a25eaeee901
Binary files /dev/null and b/KelvinDashboardGUI/Resources/Icons/icon.png differ
diff --git a/KelvinDashboardGUI/Resources/Icons/iconErrorNetwork.png b/KelvinDashboardGUI/Resources/Icons/iconErrorNetwork.png
new file mode 100644
index 0000000000000000000000000000000000000000..57fa419adeeb2cd4c7de38cf11d9ca445b628f25
Binary files /dev/null and b/KelvinDashboardGUI/Resources/Icons/iconErrorNetwork.png differ
diff --git a/KelvinDashboardGUI/Resources/Icons/iconNetwork.png b/KelvinDashboardGUI/Resources/Icons/iconNetwork.png
new file mode 100644
index 0000000000000000000000000000000000000000..aa2d0ac25a1a88aeebe52eb8cb9dada732a46287
Binary files /dev/null and b/KelvinDashboardGUI/Resources/Icons/iconNetwork.png differ
diff --git a/KelvinDashboardGUI/main.cpp b/KelvinDashboardGUI/main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e60dff573ee0df2c8d5bad00fc9f6450b3fff9c4
--- /dev/null
+++ b/KelvinDashboardGUI/main.cpp
@@ -0,0 +1,55 @@
+#include <QApplication>
+#include <QGuiApplication>
+#include <QtQml>
+#include <QQmlApplicationEngine>
+#include <QQmlContext>
+#include <QIcon>
+#include <QSystemSemaphore>
+#include <QSharedMemory>
+
+#include "DapHalper.h"
+#include "DapClient.h"
+#include "DapScreenLogin.h"
+
+int main(int argc, char *argv[])
+{
+ // Creating a semaphore for locking external resources, as well as initializing an external resource-memory
+ QSystemSemaphore systemSemaphore(QString("systemSemaphore for %1").arg("KelvinDashboardGUI"), 1);
+#ifndef Q_OS_WIN
+ QSharedMemory memmoryAppBagFix(QString("memmory for %1").arg("KelvinDashboardGUI"));
+#endif
+ QSharedMemory memmoryApp(QString("memmory for %1").arg("KelvinDashboardGUI"));
+ // Check for the existence of a running instance of the program
+ bool isRunning = DapHalper::getInstance().checkExistenceRunningInstanceApp(systemSemaphore, memmoryApp, memmoryAppBagFix);
+
+ if(isRunning)
+ {
+ return 1;
+ }
+
+ QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
+
+ QApplication app(argc, argv);
+ app.setOrganizationName("DEMLABS");
+ app.setOrganizationDomain("demlabs.com");
+ app.setApplicationName("Kelvin Client");
+ app.setWindowIcon(QIcon(":/Resources/Icons/icon.ico"));
+
+ // Set the name of the service connection
+ DapClient::getInstance().setNameSrvice(app.applicationName());
+ // We establish a connection with the service
+ DapClient::getInstance().connectToService("Kelvin Client");
+
+ qmlRegisterType<DapScreenLogin>("KelvinDashboard", 1, 0, "DapScreenLogin");
+ qmlRegisterSingletonType<DapClient>("KelvinDashboard", 1, 0, "DapClient", DapClient::singletonProvider);
+
+ QQmlApplicationEngine engine;
+ engine.rootContext()->setContextProperty("dapClient", &DapClient::getInstance());
+ engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
+
+
+ if (engine.rootObjects().isEmpty())
+ return -1;
+
+ return app.exec();
+}
diff --git a/KelvinDashboardGUI/main.qml b/KelvinDashboardGUI/main.qml
new file mode 100644
index 0000000000000000000000000000000000000000..d4cb179c1f283d82e6e1fa7b7c55c6cab09841f4
--- /dev/null
+++ b/KelvinDashboardGUI/main.qml
@@ -0,0 +1,152 @@
+import QtQuick 2.9
+import QtQuick.Controls 1.4
+import QtQuick.Controls 2.4
+import QtQuick.Window 2.0
+import QtQuick.Controls.Styles 1.4
+import Qt.labs.platform 1.0
+
+ApplicationWindow {
+ id: window
+ visible: true
+ width: 640
+ height: 480
+
+ onClosing: {
+ window.hide()
+ }
+
+ Connections {
+ target: dapClient
+
+ onActivateWindow: {
+ if(window.visibility === Window.Hidden) {
+ window.show()
+ window.raise()
+ window.requestActivate()
+ } else {
+ window.hide()
+ }
+ }
+
+ onErrorConnect: {
+ imageNetwork.visible = false
+ if(imageErrorNetwork.visible)
+ imageErrorNetwork.visible = false
+ else
+ imageErrorNetwork.visible = true
+ }
+
+ onConnectedToService: {
+ imageNetwork.visible = true
+ imageErrorNetwork.visible = false
+ console.log("Connected")
+ }
+ }
+
+
+ header: ToolBar {
+ contentHeight: buttomMenu.implicitHeight
+ spacing: 20
+ ToolButton {
+ id: buttomMenu
+ text: stackView.depth > 1 ? "\u25C0" : "\u2630"
+ font.pixelSize: Qt.application.font.pixelSize * 1.6
+ onClicked: {
+ if (stackView.depth > 1) {
+ stackView.pop()
+ } else {
+ drawerMenu.open()
+ }
+ }
+ }
+
+ Label {
+ id: labelTitleWidget
+ text: stackView.currentItem.title
+ anchors.centerIn: parent
+ }
+
+ Image {
+ id: imageNetwork
+ source: "qrc:/Resources/Icons/iconNetwork.png"
+ scale: 0.7
+ visible: false
+ anchors.verticalCenter: parent.verticalCenter
+ anchors.right: labelBalance.left
+ }
+
+ Image {
+ id: imageErrorNetwork
+ source: "qrc:/Resources/Icons/iconErrorNetwork.png"
+ scale: 0.7
+ visible: true
+ anchors.verticalCenter: parent.verticalCenter
+ anchors.right: labelBalance.left
+ }
+
+ Text {
+ id: labelBalance
+ text: "$0"
+ font.pointSize: 16
+ anchors.verticalCenter: parent.verticalCenter
+ anchors.right: parent.right
+ anchors.rightMargin: 10
+ }
+ }
+
+ Drawer {
+ id: drawerMenu
+ width: window.width * 0.25
+ height: window.height
+
+ ListView {
+ id: listViewMenu
+ anchors.fill: parent
+ model: listModelMenu
+
+ DapUiQmlListModelWidgets {
+ id: listModelMenu
+ }
+
+ delegate:
+ Component {
+ id: listViewItemMenu
+ Item {
+ id: itemMenu
+
+ width: listViewMenu.width
+ height: textItemMenu.height + 10
+
+ Row {
+ anchors.margins: 5
+ anchors.fill: parent
+
+ Text
+ {
+ id: textItemMenu
+ text: qsTr(name)
+ }
+ }
+
+ MouseArea {
+ anchors.fill: parent
+ onClicked:
+ {
+ listViewMenu.currentIndex = index
+ stackView.push(Qt.resolvedUrl(page), StackView.Immediate)
+ drawerMenu.close()
+ }
+ }
+ }
+ }
+ highlight: Rectangle { color: "aliceblue"; radius: 5 }
+ focus: true
+ }
+ }
+
+ StackView {
+ id: stackView
+ initialItem: "DapUiQmlScreenDashboard.qml"
+ anchors.fill: parent
+ }
+}
diff --git a/KelvinDashboardGUI/qml.qrc b/KelvinDashboardGUI/qml.qrc
new file mode 100644
index 0000000000000000000000000000000000000000..175c215a6a73c3c823aa9d7cb29e78bb07aa98b2
--- /dev/null
+++ b/KelvinDashboardGUI/qml.qrc
@@ -0,0 +1,25 @@
+<RCC>
+ <qresource prefix="/">
+ <file>main.qml</file>
+ <file>DapUiQmlScreenDashboard.qml</file>
+ <file>DapUiQmlScreenMainWindow.ui.qml</file>
+ <file>KelvinDashboardGUI.conf</file>
+ <file>DapUiQmlScreenLogin.ui.qml</file>
+ <file>DapUiQmlWidgetChainBlockExplorer.ui.qml</file>
+ <file>DapUiQmlWidgetChainExchanges.ui.qml</file>
+ <file>DapUiQmlWidgetChainServicesClient.ui.qml</file>
+ <file>DapUiQmlWidgetChainServicesShareControl.ui.qml</file>
+ <file>DapUiQmlWidgetChainSettings.ui.qml</file>
+ <file>DapUiQmlWidgetChainWallet.ui.qml</file>
+ <file>DapUiQmlScreenDialog.qml</file>
+ <file>Resources/Icons/icon.png</file>
+ <file>Resources/Icons/icon.ico</file>
+ <file>DapUiQmlListModelWidgets.qml</file>
+ <file>Resources/Icons/add.png</file>
+ <file>DapQmlScreenLogin.qml</file>
+ <file>DapUiQmlScreenAbout.ui.qml</file>
+ <file>DapQmlScreenAbout.qml</file>
+ <file>Resources/Icons/iconErrorNetwork.png</file>
+ <file>Resources/Icons/iconNetwork.png</file>
+ </qresource>
+</RCC>
diff --git a/KelvinDashboardService/DapChainDashboardAuth.cpp b/KelvinDashboardService/DapChainDashboardAuth.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f9d3392ae85768c74a8ebd69ccbf0bec1e5600b2
--- /dev/null
+++ b/KelvinDashboardService/DapChainDashboardAuth.cpp
@@ -0,0 +1,38 @@
+#include "DapChainDashboardAuth.h"
+
+/// Standart constructor.
+DapChainDashboardAuth::DapChainDashboardAuth(QObject *parent) : QObject(parent)
+{
+
+}
+
+/// Get user password.
+/// @return User password.
+QString DapChainDashboardAuth::getPassword() const
+{
+ return m_password;
+}
+
+/// Set user password.
+/// @param password User password.
+void DapChainDashboardAuth::setPassword(const QString &password)
+{
+ m_password = password;
+}
+
+/// Execute the command.
+/// @param command Executable command.
+void DapChainDashboardAuth::runCommand(const DapCommand &command)
+{
+ qDebug() << "Run command authorization";
+ DapCommand *answerCommand = new DapCommand(TypeDapCommand::Authorization);
+ answerCommand->setCountArguments(1);
+ if(getPassword() == command.getArgument(0).toString())
+ answerCommand->addArgument(true);
+ else
+ answerCommand->addArgument(false);
+ emit onCommandCompleted(*answerCommand);
+}
+
+
+
diff --git a/KelvinDashboardService/DapChainDashboardAuth.h b/KelvinDashboardService/DapChainDashboardAuth.h
new file mode 100644
index 0000000000000000000000000000000000000000..9adf631821311c666c99632ad063e7f7e85b8f78
--- /dev/null
+++ b/KelvinDashboardService/DapChainDashboardAuth.h
@@ -0,0 +1,48 @@
+/****************************************************************************
+**
+** This file is part of the KelvinDashboardService application.
+**
+** The class implements the authorization object. Stores the user password,
+** provides a user authorization mechanism in the service.
+**
+****************************************************************************/
+
+#ifndef DAPCHAINDASHBOARDAUTH_H
+#define DAPCHAINDASHBOARDAUTH_H
+
+#include <QObject>
+
+#include "DapCommand.h"
+
+class DapChainDashboardAuth : public QObject
+{
+ Q_OBJECT
+
+protected:
+ /// User password.
+ QString m_password = "123";
+
+public:
+ /// Standart constructor.
+ explicit DapChainDashboardAuth(QObject *parent = nullptr);
+
+ ///********************************************
+ /// Interface
+ /// *******************************************
+ /// Get user password.
+ /// @return User password.
+ QString getPassword() const;
+ /// Set user password.
+ /// @param password User password.
+ void setPassword(const QString &password);
+ /// Execute the command.
+ /// @param command Executable command.
+ void runCommand(const DapCommand& command);
+
+signals:
+ /// The signal is emitted when the command is successful.
+ /// @param command The executed command.
+ void onCommandCompleted(const DapCommand& command);
+};
+
+#endif // DAPCHAINDASHBOARDAUTH_H
diff --git a/KelvinDashboardService/DapChainDashboardService.cpp b/KelvinDashboardService/DapChainDashboardService.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..618a4b397abd59fb71376d64ff68295bbf92a1ac
--- /dev/null
+++ b/KelvinDashboardService/DapChainDashboardService.cpp
@@ -0,0 +1,85 @@
+#include "DapChainDashboardService.h"
+
+DapChainDashboardService::DapChainDashboardService(QObject *parent) : QObject(parent)
+{
+ // Creating a local server to establish connection with the GUI client and then connect to it.
+ m_dapLocalServer = new DapLocalServer("Kelvin Client");
+ m_dapLocalServer->connectWithClient();
+
+ // Signal-slot connection that triggers the identification of a received command.
+ connect(m_dapLocalServer, &DapLocalServer::commandRecieved, this, &DapChainDashboardService::identificationCommand);
+ // Signal-slot connection, starts processing the user authorization command.
+ connect(&m_dapChainDashboardAuth, &DapChainDashboardAuth::onCommandCompleted, m_dapLocalServer, &DapLocalServer::sendCommand);
+}
+
+/// Identification of the command received.
+/// @param command Command received
+/// @return Returns true if the command is identified, otherwise - false.
+bool DapChainDashboardService::identificationCommand(const DapCommand &command)
+{
+ qDebug() << "Identification command: " << command.getTypeCommand();
+ switch (command.getTypeCommand())
+ {
+ // User authorization
+ case TypeDapCommand::Authorization:
+ m_dapChainDashboardAuth.runCommand(command);
+ return true;
+ default:
+ return false;
+ }
+}
+
+/// Activate the main client window by double-clicking the application icon in the system tray.
+/// @param reason Type of action on the icon in the system tray.
+void DapChainDashboardService::clientActivated(const QSystemTrayIcon::ActivationReason& reason)
+{
+ qDebug() << "Client activated";
+ switch (reason)
+ {
+ case QSystemTrayIcon::Trigger:
+ {
+ if(m_dapLocalServer->isClientExist())
+ {
+ qDebug() << "Send command activated";
+ DapCommand *command = new DapCommand(TypeDapCommand::ActivateWindowClient, {true});
+ m_dapLocalServer->sendCommand(*command);
+ }
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+/// Shut down client.
+void DapChainDashboardService::closeClient()
+{
+ DapCommand *command = new DapCommand(TypeDapCommand::CloseClient, {true});
+ m_dapLocalServer->sendCommand(*command);
+}
+
+/// System tray initialization.
+void DapChainDashboardService::initTray()
+{
+ QSystemTrayIcon *trayIconKelvinDashboard = new QSystemTrayIcon();
+ trayIconKelvinDashboard->setIcon(QIcon(":/Resources/Icons/icon.ico"));
+ trayIconKelvinDashboard->setToolTip("KelvinDashboard");
+ QMenu * menuKelvinDashboardService = new QMenu();
+ QAction * quitAction = new QAction("Выход");
+ menuKelvinDashboardService->addAction(quitAction);
+ trayIconKelvinDashboard->setContextMenu(menuKelvinDashboardService);
+ trayIconKelvinDashboard->show();
+
+ // If the "Exit" menu item is selected, then we shut down the service,
+ // and also send a command to shut down the client.
+ connect(quitAction, &QAction::triggered, this, [=]
+ {
+ closeClient();
+ qApp->quit();
+ });
+
+ // With a double click on the icon in the system tray,
+ // we send a command to the client to activate the main window
+ connect(trayIconKelvinDashboard, SIGNAL(activated(QSystemTrayIcon::ActivationReason)),
+ this, SLOT(clientActivated(QSystemTrayIcon::ActivationReason)));
+}
diff --git a/KelvinDashboardService/DapChainDashboardService.h b/KelvinDashboardService/DapChainDashboardService.h
new file mode 100644
index 0000000000000000000000000000000000000000..ef4d75b9af12732caf65f567a8b1080726370d5f
--- /dev/null
+++ b/KelvinDashboardService/DapChainDashboardService.h
@@ -0,0 +1,51 @@
+/****************************************************************************
+**
+** This file is part of the KelvinDashboardService application.
+**
+** The class implements the main application object CalvinDashboardService.
+** It involves the implementation of the interaction of all the components
+** of the service components. For example, identification of commands,
+** control of the authorization mechanism, management of an GUI client, etc.
+**
+****************************************************************************/
+
+#ifndef DAPCHAINDASHBOARDSERVICE_H
+#define DAPCHAINDASHBOARDSERVICE_H
+
+#include <QObject>
+#include <QSystemTrayIcon>
+#include <QMenu>
+#include <QAction>
+#include <QApplication>
+
+#include "DapLocalServer.h"
+#include "DapChainDashboardAuth.h"
+
+class DapChainDashboardService : public QObject
+{
+ Q_OBJECT
+
+ /// The object responsible for authorization of the user in the application.
+ DapChainDashboardAuth m_dapChainDashboardAuth;
+ /// Local server for establishing connection with GUI client.
+ DapLocalServer *m_dapLocalServer;
+public:
+ /// Standard Ñonstructor.
+ explicit DapChainDashboardService(QObject *parent = nullptr);
+
+public slots:
+ /// Identification of the command received.
+ /// @param command Command received.
+ /// @return Returns true if the command is identified, otherwise - false.
+ bool identificationCommand(const DapCommand &command);
+ /// Activate the main client window by double-clicking the application icon in the system tray.
+ /// @param reason Type of action on the icon in the system tray.
+ void clientActivated(const QSystemTrayIcon::ActivationReason& reason);
+ /// Shut down client.
+ void closeClient();
+ /// System tray initialization.
+ void initTray();
+
+};
+
+#endif // DAPCHAINDASHBOARDSERVICE_H
diff --git a/KelvinDashboardService/DapChainNode.cpp b/KelvinDashboardService/DapChainNode.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a401f9bdf38fe191dd9780aa28a4b4c3a10ce878
--- /dev/null
+++ b/KelvinDashboardService/DapChainNode.cpp
@@ -0,0 +1,6 @@
+#include "DapChainNode.h"
+
+DapChainNode::DapChainNode(QObject *parent) : QObject(parent)
+{
+
+}
diff --git a/KelvinDashboardService/DapChainNode.h b/KelvinDashboardService/DapChainNode.h
new file mode 100644
index 0000000000000000000000000000000000000000..17fd7a59ee7a569c9dda5453072d40c75b76df06
--- /dev/null
+++ b/KelvinDashboardService/DapChainNode.h
@@ -0,0 +1,17 @@
+#ifndef DAPCHAINNODE_H
+#define DAPCHAINNODE_H
+
+#include <QObject>
+
+class DapChainNode : public QObject
+{
+ Q_OBJECT
+public:
+ explicit DapChainNode(QObject *parent = nullptr);
+
+signals:
+
+public slots:
+};
+
+#endif // DAPCHAINNODE_H
\ No newline at end of file
diff --git a/KelvinDashboardService/DapChainNodeCache.cpp b/KelvinDashboardService/DapChainNodeCache.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b7874dff69638ce53ee5a381a87ddf0f3b3ea26f
--- /dev/null
+++ b/KelvinDashboardService/DapChainNodeCache.cpp
@@ -0,0 +1,6 @@
+#include "DapChainNodeCache.h"
+
+DapChainNodeCache::DapChainNodeCache(QObject *parent) : QObject(parent)
+{
+
+}
diff --git a/KelvinDashboardService/DapChainNodeCache.h b/KelvinDashboardService/DapChainNodeCache.h
new file mode 100644
index 0000000000000000000000000000000000000000..2404694b73175474ec2febf18b884db91f59b7ff
--- /dev/null
+++ b/KelvinDashboardService/DapChainNodeCache.h
@@ -0,0 +1,17 @@
+#ifndef DAPCHAINNODECACHE_H
+#define DAPCHAINNODECACHE_H
+
+#include <QObject>
+
+class DapChainNodeCache : public QObject
+{
+ Q_OBJECT
+public:
+ explicit DapChainNodeCache(QObject *parent = nullptr);
+
+signals:
+
+public slots:
+};
+
+#endif // DAPCHAINNODECACHE_H
\ No newline at end of file
diff --git a/KelvinDashboardService/KelvinDashboardService.pro b/KelvinDashboardService/KelvinDashboardService.pro
new file mode 100644
index 0000000000000000000000000000000000000000..8f5f5c19bf01ba50becf65efcbd6c13201070bef
--- /dev/null
+++ b/KelvinDashboardService/KelvinDashboardService.pro
@@ -0,0 +1,57 @@
+QT += network widgets
+QT += gui
+
+CONFIG += c++11
+CONFIG -= app_bundle
+
+!defined(BRAND,var){
+# Default brand
+ BRAND = KelvinDashboard
+}
+
+TARGET = $${BRAND}Service
+
+VER_MAJ = 1
+VER_MIN = 0
+VER_PAT = 0
+
+ICON = icon.ico
+
+win32 {
+ VERSION = $${VER_MAJ}.$${VER_MIN}.$$VER_PAT
+}
+else {
+ VERSION = $$VER_MAJ\.$$VER_MIN\-$$VER_PAT
+}
+
+# The following define makes your compiler emit warnings if you use
+# any feature of Qt which as been marked deprecated (the exact warnings
+# depend on your compiler). Please consult the documentation of the
+# deprecated API in order to know how to port your code away from it.
+DEFINES += QT_DEPRECATED_WARNINGS
+
+# You can also make your code fail to compile if you use deprecated APIs.
+# In order to do so, uncomment the following line.
+# You can also select to disable deprecated APIs only up to a certain version of Qt.
+#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0
+
+SOURCES += \
+ main.cpp \
+ DapChainDashboardService.cpp \
+ DapChainDashboardAuth.cpp \
+ DapChainNode.cpp \
+ DapChainNodeCache.cpp
+
+HEADERS += \
+ DapChainDashboardService.h \
+ DapChainDashboardAuth.h \
+ DapChainNode.h \
+ DapChainNodeCache.h
+
+include (../libKelvinDashboardCommon/libKelvinDashboardCommon.pri)
+INCLUDEPATH += $$_PRO_FILE_PWD_/../libKelvinDashboardCommon/
+
+RESOURCES += \
+ KelvinDashboardService.qrc
+
+DISTFILES +=
diff --git a/KelvinDashboardService/KelvinDashboardService.qrc b/KelvinDashboardService/KelvinDashboardService.qrc
new file mode 100644
index 0000000000000000000000000000000000000000..e1b0195c21621b97fa3efbdcbd394dc84c164ac1
--- /dev/null
+++ b/KelvinDashboardService/KelvinDashboardService.qrc
@@ -0,0 +1,7 @@
+<RCC>
+ <qresource prefix="/">
+ <file>Resources/Icons/add.png</file>
+ <file>Resources/Icons/icon.ico</file>
+ <file>Resources/Icons/icon.png</file>
+ </qresource>
+</RCC>
diff --git a/KelvinDashboardService/Resources/Icons/add.png b/KelvinDashboardService/Resources/Icons/add.png
new file mode 100644
index 0000000000000000000000000000000000000000..f3c75ff7cc06fe9833492a80f6bd7ddcfefe3072
Binary files /dev/null and b/KelvinDashboardService/Resources/Icons/add.png differ
diff --git a/KelvinDashboardService/Resources/Icons/icon.ico b/KelvinDashboardService/Resources/Icons/icon.ico
new file mode 100644
index 0000000000000000000000000000000000000000..41230db92cb8101b8f24cf6f861082c6dfb827e1
Binary files /dev/null and b/KelvinDashboardService/Resources/Icons/icon.ico differ
diff --git a/KelvinDashboardService/Resources/Icons/icon.png b/KelvinDashboardService/Resources/Icons/icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..52525ef9e99b9d42242dcddc0f5f5a25eaeee901
Binary files /dev/null and b/KelvinDashboardService/Resources/Icons/icon.png differ
diff --git a/KelvinDashboardService/main.cpp b/KelvinDashboardService/main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d6308ba276fc2bd038afd35211f1f65b796ce928
--- /dev/null
+++ b/KelvinDashboardService/main.cpp
@@ -0,0 +1,35 @@
+#include <QApplication>
+#include <QSystemSemaphore>
+#include <QSharedMemory>
+
+#include "DapHalper.h"
+#include "DapChainDashboardService.h"
+
+int main(int argc, char *argv[])
+{
+ // Creating a semaphore for locking external resources, as well as initializing an external resource-memory
+ QSystemSemaphore systemSemaphore(QString("systemSemaphore for %1").arg("KelvinDashboardService"), 1);
+#ifndef Q_OS_WIN
+ QSharedMemory memmoryAppBagFix(QString("memmory for %1").arg("KelvinDashboardService"));
+#endif
+ QSharedMemory memmoryApp(QString("memmory for %1").arg("KelvinDashboardService"));
+ // Check for the existence of a running instance of the program
+ bool isRunning = DapHalper::getInstance().checkExistenceRunningInstanceApp(systemSemaphore, memmoryApp, memmoryAppBagFix);
+
+ if(isRunning)
+ {
+ return 1;
+ }
+
+ QApplication a(argc, argv);
+ a.setOrganizationName("DEMLABS");
+ a.setOrganizationDomain("demlabs.com");
+ a.setApplicationName("KelvinDashboardService");
+
+ // Creating the main application object
+ DapChainDashboardService service;
+ // Initialization of the application in the system tray
+ service.initTray();
+
+ return a.exec();
+}
diff --git a/libKelvinDashboardCommon/DapCommand.cpp b/libKelvinDashboardCommon/DapCommand.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..37294267ce97b8bf3fbfcb2852f13364470a099a
--- /dev/null
+++ b/libKelvinDashboardCommon/DapCommand.cpp
@@ -0,0 +1,124 @@
+#include "DapCommand.h"
+
+/// Redefined Ñonstructor.
+/// @param byteArray Interpreting a Ñommand in a byte array.
+DapCommand::DapCommand(const QByteArray &byteArray)
+{
+ this->deserialize(byteArray);
+}
+
+/// Add argument.
+/// @param argument The argument.
+void DapCommand::addArgument(const QVariant &argument)
+{
+ m_arguments.push_back(argument);
+}
+
+/// Get the number of arguments.
+/// @return Number of arguments.
+unsigned DapCommand::getCountArguments() const
+{
+ return m_countArguments;
+}
+
+/// Set the number of arguments.
+/// @return Number of arguments.
+void DapCommand::setCountArguments(const unsigned &countArguments)
+{
+ m_countArguments = countArguments;
+}
+
+/// Get the type of command.
+/// @return The type of command.
+const TypeDapCommand& DapCommand::getTypeCommand() const
+{
+ return m_typeCommand;
+}
+
+/// Set the type of command.
+/// @param The type of command.
+void DapCommand::setTypeCommand(const TypeDapCommand &typeCommand)
+{
+ m_typeCommand = typeCommand;
+}
+
+/// Get an argument.
+/// @param pos The position of the argument in the collection of arguments.
+/// @return The argument.
+QVariant DapCommand::getArgument(int pos) const
+{
+ if(!m_arguments.isEmpty() && pos >=0 && pos < m_arguments.size())
+ return m_arguments.at(pos);
+ return QVariant();
+}
+
+/// Get a collection of arguments.
+/// @return Сollection of arguments.
+const QVector<QVariant>& DapCommand::getArguments() const
+{
+ return m_arguments;
+}
+
+/// Set a collection of arguments.
+/// @return arguments Сollection of arguments.
+void DapCommand::setArguments(const std::initializer_list<QVariant> &arguments)
+{
+ m_arguments.append(arguments);
+}
+
+/// Set a collection of arguments.
+/// @return arguments Сollection of arguments.
+void DapCommand::setArguments(const QVector<QVariant> &arguments)
+{
+ m_arguments.append(arguments);
+}
+
+/// Serialize a command to a byte array.
+/// @return A serialized command interpreted as a byte array.
+const QByteArray &DapCommand::serialize()
+{
+ QDataStream output( &m_byteArrayBuffer, QIODevice::WriteOnly );
+ output << (*this);
+ return m_byteArrayBuffer;
+}
+
+/// Deserialization of a command from a byte array.
+/// @param byteArray A serialized command interpreted as a byte array.
+void DapCommand::deserialize(const QByteArray &byteArray)
+{
+ QDataStream input(byteArray);
+ input>>(*this);
+}
+
+/// Overloaded version of stream output.
+/// @param ds Binary data stream.
+/// @param dapCommand The command.
+QDataStream& operator <<(QDataStream &dataStream, const DapCommand &dapCommand)
+{
+ dataStream << dapCommand.getTypeCommand() << dapCommand.getCountArguments();
+ for(const QVariant& argument : dapCommand.getArguments())
+ {
+ dataStream << argument;
+ }
+ return dataStream;
+}
+
+/// Overloaded version of streaming input.
+/// @param ds Binary data stream.
+/// @param dapCommand The command.
+QDataStream& operator >>(QDataStream &dataStream, DapCommand &dapCommand)
+{
+ int typeCommand{0};
+ unsigned countArguments{0};
+ dataStream >> typeCommand >> countArguments;
+ dapCommand.setTypeCommand(static_cast<TypeDapCommand>(typeCommand));
+ dapCommand.setCountArguments(countArguments);
+ for(register unsigned a{0}; a < countArguments; ++a)
+ {
+ QVariant argument;
+ dataStream >> argument;
+ dapCommand.addArgument(argument);
+ }
+
+ return dataStream;
+}
diff --git a/libKelvinDashboardCommon/DapCommand.h b/libKelvinDashboardCommon/DapCommand.h
new file mode 100644
index 0000000000000000000000000000000000000000..b326121686f2506597ade3c3d7db2d7e4178d8f3
--- /dev/null
+++ b/libKelvinDashboardCommon/DapCommand.h
@@ -0,0 +1,123 @@
+/****************************************************************************
+**
+** This file is part of the libKelvinDashboardClient library.
+**
+** The class implements the essence of the command. The signature of the
+** command includes: the type of the command, the number of arguments in
+** the command, a collection of arguments of the type QVariant.
+**
+****************************************************************************/
+
+#ifndef DAPCOMMAND_H
+#define DAPCOMMAND_H
+
+#include <QVector>
+#include <QString>
+#include <QByteArray>
+#include <QIODevice>
+#include <QDataStream>
+#include <QDebug>
+#include <initializer_list>
+
+/****************************************************************************
+**
+** This file is part of the libKelvinDashboardClient library.
+**
+** The enum type implements the nomenclature of commands used in client-server
+** communication.
+**
+****************************************************************************/
+
+enum TypeDapCommand
+{
+ None, // Type is undefined
+ Authorization, // User authorization
+ ActivateWindowClient, // Activate the main application window if minimized to the system tray
+ CheckExistenceClient, // Checking the existence of a client connected to the server
+ CloseClient // Shut down the client
+};
+
+class DapCommand
+{
+ /// Overloaded version of stream output.
+ /// @param ds Binary data stream.
+ /// @param dapCommand The command.
+ friend QDataStream& operator<<(QDataStream &ds, const DapCommand &dapCommand);
+ /// Overloaded version of streaming input.
+ /// @param ds Binary data stream.
+ /// @param dapCommand The command.
+ friend QDataStream& operator>>(QDataStream &ds, DapCommand &dapCommand);
+
+protected:
+ /// Type of the command.
+ TypeDapCommand m_typeCommand {TypeDapCommand::None};
+ /// Number of arguments.
+ unsigned m_countArguments{0};
+ /// Collection of the command.
+ QVector<QVariant> m_arguments;
+ /// Interpreting a Ñommand in a byte array.
+ QByteArray m_byteArrayBuffer;
+
+public:
+ /// Standart constructor.
+ DapCommand() = default;
+ /// Redefined Ñonstructor.
+ /// @param byteArray Interpreting a Ñommand in a byte array.
+ DapCommand(const QByteArray& byteArray);
+ /// Redefined Ñonstructor.
+ /// @param typeCommand The type of command.
+ DapCommand(const TypeDapCommand &typeCommand) : m_typeCommand(typeCommand) { }
+ /// Redefined Ñonstructor.
+ /// @param typeCommand The type of command.
+ /// @param countArguments Number of arguments.
+ /// @param args Сollection of arguments.
+ DapCommand(const TypeDapCommand &typeCommand, const unsigned& countArguments, const std::initializer_list<QVariant> &args)
+ : m_typeCommand(typeCommand), m_countArguments(countArguments), m_arguments(args) { }
+ /// Redefined Ñonstructor.
+ /// @param typeCommand The type of command.
+ /// @param args Сollection of arguments.
+ DapCommand(const TypeDapCommand &typeCommand, const std::initializer_list<QVariant> &args)
+ : m_typeCommand(typeCommand), m_arguments(args) { }
+
+ ///********************************************
+ /// Interface
+ /// *******************************************
+
+ /// Get the type of command.
+ /// @return The type of command.
+ const TypeDapCommand &getTypeCommand() const;
+ /// Set the type of command.
+ /// @param The type of command.
+ void setTypeCommand(const TypeDapCommand &typeCommand);
+ /// Get an argument.
+ /// @param pos The position of the argument in the collection of arguments.
+ /// @return The argument.
+ QVariant getArgument(int pos) const;
+ /// Get a collection of arguments.
+ /// @return Сollection of arguments.
+ const QVector<QVariant> &getArguments() const;
+ /// Set a collection of arguments.
+ /// @param arguments Сollection of arguments.
+ void setArguments(const std::initializer_list<QVariant> &arguments);
+ /// Set a collection of arguments.
+ /// @return arguments Сollection of arguments.
+ void setArguments(const QVector<QVariant> &arguments);
+ /// Serialize a command to a byte array.
+ /// @return A serialized command interpreted as a byte array.
+ const QByteArray &serialize();
+ /// Deserialization of a command from a byte array.
+ /// @param byteArray A serialized command interpreted as a byte array.
+ void deserialize(const QByteArray &byteArray);
+ /// Get the number of arguments.
+ /// @return Number of arguments.
+ unsigned getCountArguments() const;
+ /// Set the number of arguments.
+ /// @return Number of arguments.
+ void setCountArguments(const unsigned& countArguments);
+ /// Add argument.
+ /// @param argument The argument.
+ void addArgument(const QVariant &argument);
+};
+
+
+#endif // DAPCOMMAND_H
diff --git a/libKelvinDashboardCommon/DapHalper.cpp b/libKelvinDashboardCommon/DapHalper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d041df2bb5738c178fba090fcd3d4c5a65a6ebc3
--- /dev/null
+++ b/libKelvinDashboardCommon/DapHalper.cpp
@@ -0,0 +1,43 @@
+#include "DapHalper.h"
+
+DapHalper::DapHalper(QObject *parent) : QObject(parent)
+{
+
+}
+
+DapHalper &DapHalper::getInstance()
+{
+ static DapHalper instance;
+ return instance;
+}
+
+/// Check for the existence of a running instance of the program.
+/// @param systemSemaphore Semaphore for blocking shared resource.
+/// @param memmoryApp Shared memory.
+/// @param memmoryAppBagFix Shared memory for Linux system features.
+/// @return If the application is running, it returns three, otherwise false.
+bool DapHalper::checkExistenceRunningInstanceApp(QSystemSemaphore& systemSemaphore, QSharedMemory &memmoryApp, QSharedMemory &memmoryAppBagFix)
+{
+ systemSemaphore.acquire();
+
+ if(memmoryAppBagFix.attach())
+ {
+ memmoryAppBagFix.detach();
+ }
+
+ bool isRunning {false};
+
+ if (memmoryApp.attach())
+ {
+ isRunning = true;
+ }
+ else
+ {
+ memmoryApp.create(1);
+ isRunning = false;
+ }
+
+ systemSemaphore.release();
+
+ return isRunning;
+}
diff --git a/libKelvinDashboardCommon/DapHalper.h b/libKelvinDashboardCommon/DapHalper.h
new file mode 100644
index 0000000000000000000000000000000000000000..0932b27780eb2aa9a443d88ac5e74fa397c523da
--- /dev/null
+++ b/libKelvinDashboardCommon/DapHalper.h
@@ -0,0 +1,39 @@
+/****************************************************************************
+**
+** This file is part of the libKelvinDashboardClient library.
+**
+** The class provides common functionality.
+**
+****************************************************************************/
+
+#ifndef DAPHALPER_H
+#define DAPHALPER_H
+
+#include <QObject>
+#include <QSystemSemaphore>
+#include <QSharedMemory>
+
+class DapHalper : public QObject
+{
+ Q_OBJECT
+
+ /// Standart constructor.
+ explicit DapHalper(QObject *parent = nullptr);
+
+public:
+ // Realization of a singleton
+ DapHalper(const DapHalper&) = delete;
+ DapHalper& operator= (const DapHalper &) = delete;
+ /// Get an instance of a class.
+ /// @return Instance of a class.
+ static DapHalper &getInstance();
+
+ /// Check for the existence of a running instance of the program.
+ /// @param systemSemaphore Semaphore for blocking shared resource.
+ /// @param memmoryApp Shared memory.
+ /// @param memmoryAppBagFix Shared memory for Linux system features.
+ /// @return If the application is running, it returns three, otherwise false.
+ bool checkExistenceRunningInstanceApp(QSystemSemaphore& systemSemaphore, QSharedMemory &memmoryApp, QSharedMemory &memmoryAppBagFix);
+};
+
+#endif // DAPHALPER_H
diff --git a/libKelvinDashboardCommon/DapLocalClient.cpp b/libKelvinDashboardCommon/DapLocalClient.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d6c16f84bde40d48859b16c271ce64f802888801
--- /dev/null
+++ b/libKelvinDashboardCommon/DapLocalClient.cpp
@@ -0,0 +1,77 @@
+#include "DapLocalClient.h"
+
+/// Redefined Ñonstructor.
+/// @param nameConnect Name of the connection. Default is empty.
+/// @param parent The default parent is empty.
+DapLocalClient::DapLocalClient(const QString &nameConnect, QObject *parent) : QLocalSocket(parent)
+{
+ Q_UNUSED(nameConnect);
+
+ // Initializing fields
+ m_nameConnect = nameConnect;
+
+ // A signal-slot connection that starts receiving a command when the socket is
+ // switched to readyRead mode
+ connect(this, &DapLocalClient::readyRead, this, &DapLocalClient::recieveCommand);
+}
+
+/// Get the name of the connection.
+/// @return Name of the connection.
+const QString &DapLocalClient::getNameConnect() const
+{
+ return m_nameConnect;
+}
+
+/// Set connection name.
+/// @param nameConnect Name of the connection.
+void DapLocalClient::setNameConnect(const QString &nameConnect)
+{
+ m_nameConnect = nameConnect;
+}
+
+/// Connect to the server.
+/// @details As the name of the connection, the NameConnect property
+/// initialized through the constructor will be used.
+void DapLocalClient::connectToServer()
+{
+ QLocalSocket::connectToServer(getNameConnect());
+}
+
+/// Connect to the server.
+/// @details The name of the connection sets the parameter.
+/// @param nameConnect Name of the connection.
+void DapLocalClient::connectToServer(const QString &nameConnect)
+{
+ QLocalSocket::connectToServer(nameConnect);
+}
+
+/// Get the command.
+/// @details When the command is received, the commandRecieved signal is emitted
+/// @return The received command.
+const DapCommand &DapLocalClient::recieveCommand()
+{
+ DapCommand *command = new DapCommand(this->readAll());
+ emit commandRecieved(*command);
+ return *command;
+}
+
+/// Set command.
+/// @details If the command is successfully sent, the commandSent signal
+/// is emitted.
+/// @param command Submitted command.
+/// @return Returns true if the command was successfully sent,
+/// false - the command was not sent.
+bool DapLocalClient::sendCommand(const DapCommand &command)
+{
+ if(this->isWritable())
+ {
+ this->write(const_cast<DapCommand &>(command).serialize());
+
+ if(this->flush())
+ {
+ emit commandSent(command);
+ return true;
+ }
+ }
+ return false;
+}
diff --git a/libKelvinDashboardCommon/DapLocalClient.h b/libKelvinDashboardCommon/DapLocalClient.h
new file mode 100644
index 0000000000000000000000000000000000000000..10989f6405f4e6fa2a09f3ef9aa1c211687c0d5a
--- /dev/null
+++ b/libKelvinDashboardCommon/DapLocalClient.h
@@ -0,0 +1,82 @@
+/****************************************************************************
+**
+** This file is part of the libKelvinDashboardClient library.
+**
+** The class extends the QLocalSocket to implement the client side. It is
+** intended for transfer of commands of type Dapsomommand between the client
+** and the server.
+**
+****************************************************************************/
+
+#ifndef DAPLOCALCLIENT_H
+#define DAPLOCALCLIENT_H
+
+#include <QObject>
+#include <QLocalSocket>
+
+#include "DapCommand.h"
+
+class DapLocalClient : public QLocalSocket
+{
+ Q_OBJECT
+
+protected:
+ /// Name of client-server connection.
+ QString m_nameConnect;
+
+public:
+ /// Redefined Ñonstructor.
+ /// @param nameConnect Name of the connection. Default is empty.
+ /// @param parent The default parent is empty.
+ explicit DapLocalClient(const QString& nameConnect = "", QObject *parent = nullptr);
+
+ ///********************************************
+ /// Properties
+ /// *******************************************
+
+ /// Name of client-server connection.
+ Q_PROPERTY(QString NameConnect MEMBER m_nameConnect READ getNameConnect WRITE setNameConnect NOTIFY nameConnectChanged)
+
+ ///********************************************
+ /// Interface
+ /// *******************************************
+
+ /// Get the name of the connection.
+ /// @return Name of the connection.
+ const QString& getNameConnect() const;
+ /// Set connection name.
+ /// @param nameConnect Name of the connection.
+ void setNameConnect(const QString &nameConnect);
+ /// Connect to the server.
+ /// @details As the name of the connection, the NameConnect property
+ /// initialized through the constructor will be used.
+ void connectToServer();
+ /// Connect to the server.
+ /// @details The name of the connection sets the parameter.
+ /// @param nameConnect Name of the connection.
+ void connectToServer(const QString &nameConnect);
+ /// Get the command.
+ /// @details When the command is received, the commandRecieved signal is emitted
+ /// @return The received command.
+ const DapCommand& recieveCommand();
+ /// Set command.
+ /// @details If the command is successfully sent, the commandSent signal
+ /// is emitted.
+ /// @param command Submitted command.
+ /// @return Returns true if the command was successfully sent,
+ /// false - the command was not sent.
+ bool sendCommand(const DapCommand &command);
+
+signals:
+ /// The signal is emitted when the NameConnect property changes.
+ /// @param nameConnect Name of the connection.
+ void nameConnectChanged(const QString &nameConnect);
+ /// The signal is emitted when a command is received.
+ /// @param command The received command.
+ void commandRecieved(const DapCommand &command);
+ /// The signal is emitted when sending a command.
+ /// @param command Submitted command.
+ void commandSent(const DapCommand &command);
+};
+
+#endif // DAPLOCALCLIENT_H
diff --git a/libKelvinDashboardCommon/DapLocalServer.cpp b/libKelvinDashboardCommon/DapLocalServer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..febc832eb74815b2411f26609088a3f9396da438
--- /dev/null
+++ b/libKelvinDashboardCommon/DapLocalServer.cpp
@@ -0,0 +1,107 @@
+#include "DapLocalServer.h"
+
+/// Redefined Ñonstructor.
+/// @param nameConnect Name of the connection. Default is empty.
+/// @param parent The default parent is empty.
+DapLocalServer::DapLocalServer(const QString &nameConnect, QObject *parent) : QLocalServer(parent)
+{
+ Q_UNUSED(nameConnect);
+
+ // Initializing fields
+ m_nameConnect = nameConnect;
+}
+
+/// Get the name of the connection.
+/// @return Name of the connection.
+const QString &DapLocalServer::getNameConnect() const
+{
+ return m_nameConnect;
+}
+
+/// Set connection name.
+/// @param nameConnect Name of the connection.
+void DapLocalServer::setNameConnect(const QString &nameConnect)
+{
+ m_nameConnect = nameConnect;
+}
+
+/// Connect with client.
+/// @details As the name of the connection, the NameConnect property
+/// initialized through the constructor will be used.
+void DapLocalServer::connectWithClient()
+{
+ connectWithClient(getNameConnect());
+}
+
+/// Connect with client.
+/// @details The name of the connection sets the parameter.
+/// @param nameConnect Name of the connection.
+void DapLocalServer::connectWithClient(const QString &nameConnect)
+{
+ this->setSocketOptions(QLocalServer::WorldAccessOption);
+
+ if(this->listen(nameConnect))
+ {
+ connect(this, &QLocalServer::newConnection, [=]
+ {
+ m_client = this->nextPendingConnection();
+ {
+ qDebug() << "Cient connected";
+ connect(m_client, &QLocalSocket::readyRead, [=]
+ {
+ QByteArray clientCommand = m_client->readAll();
+
+ while (true) {
+ if(clientCommand.isEmpty())
+ break;
+
+ recieveCommand(clientCommand);
+ break;
+ }
+ });
+ }
+ });
+ }
+}
+
+/// Get the command.
+/// @details When the command is received, the commandRecieved signal is emitted.
+/// @param byteArrayCommand Accepted command in byte representation.
+/// @return The received command.
+const DapCommand& DapLocalServer::recieveCommand(const QByteArray &byteArrayCommand)
+{
+ DapCommand *command = new DapCommand(byteArrayCommand);
+ emit commandRecieved(*command);
+ return *command;
+}
+
+/// Set command.
+/// @details If the command is successfully sent, the commandSent signal
+/// is emitted.
+/// @param command Submitted command.
+/// @return Returns true if the command was successfully sent,
+/// false - the command was not sent.
+bool DapLocalServer::sendCommand(const DapCommand &command)
+{
+ if(m_client->isWritable())
+ {
+ qDebug() << "Send command by: " << const_cast<DapCommand &>(command).serialize();
+ qDebug() << "Send command: " << command.getArguments().at(0);
+ m_client->write(const_cast<DapCommand &>(command).serialize());
+
+ if(m_client->flush())
+ {
+ emit commandSent(command);
+ return true;
+ }
+ }
+ return false;
+}
+
+/// Check the existence of the connected client.
+/// @return Returns three if the client is connected to the server,
+/// false is not connected.
+bool DapLocalServer::isClientExist()
+{
+ return m_client ? true : false;
+}
diff --git a/libKelvinDashboardCommon/DapLocalServer.h b/libKelvinDashboardCommon/DapLocalServer.h
new file mode 100644
index 0000000000000000000000000000000000000000..33a9349615702a46292832f164a33ac59412d722
--- /dev/null
+++ b/libKelvinDashboardCommon/DapLocalServer.h
@@ -0,0 +1,93 @@
+/****************************************************************************
+**
+** This file is part of the libKelvinDashboardClient library.
+**
+** The class extends QLocalServer to implement the server side. It is
+** intended for transfer of commands of type Dapsomommand between the server
+** and the client.
+**
+****************************************************************************/
+
+#ifndef DAPLOCALSERVER_H
+#define DAPLOCALSERVER_H
+
+#include <QObject>
+#include <QString>
+#include <QLocalServer>
+#include <QLocalSocket>
+#include <QDebug>
+
+#include "DapCommand.h"
+
+class DapLocalServer : public QLocalServer
+{
+ Q_OBJECT
+
+protected:
+ /// Name of client-server connection.
+ QString m_nameConnect;
+ /// Client connected to the server.
+ QLocalSocket *m_client {nullptr};
+
+public:
+ /// Redefined Ñonstructor.
+ /// @param nameConnect Name of the connection. Default is empty.
+ /// @param parent The default parent is empty.
+ explicit DapLocalServer(const QString& nameConnect, QObject *parent = nullptr);
+
+ ///********************************************
+ /// Properties
+ /// *******************************************
+
+ /// Name of client-server connection.
+ Q_PROPERTY(QString NameConnect MEMBER m_nameConnect READ getNameConnect WRITE setNameConnect NOTIFY nameConnectChanged)
+
+
+ ///********************************************
+ /// Interface
+ /// *******************************************
+
+ /// Get the name of the connection.
+ /// @return Name of the connection.
+ const QString& getNameConnect() const;
+ /// Set connection name.
+ /// @param nameConnect Name of the connection.
+ void setNameConnect(const QString &nameConnect);
+ /// Connect with client.
+ /// @details As the name of the connection, the NameConnect property
+ /// initialized through the constructor will be used.
+ void connectWithClient();
+ /// Connect with client.
+ /// @details The name of the connection sets the parameter.
+ /// @param nameConnect Name of the connection.
+ void connectWithClient(const QString &nameConnect);
+ /// Get the command.
+ /// @details When the command is received, the commandRecieved signal is emitted.
+ /// @param byteArrayCommand Accepted command in byte representation.
+ /// @return The received command.
+ const DapCommand &recieveCommand(const QByteArray& byteArrayCommand);
+ /// Set command.
+ /// @details If the command is successfully sent, the commandSent signal
+ /// is emitted.
+ /// @param command Submitted command.
+ /// @return Returns true if the command was successfully sent,
+ /// false - the command was not sent.
+ bool sendCommand(const DapCommand &command);
+ /// Check the existence of the connected client.
+ /// @return Returns three if the client is connected to the server,
+ /// false is not connected.
+ Q_INVOKABLE bool isClientExist();
+
+signals:
+ /// The signal is emitted when the NameConnect property changes.
+ /// @param nameConnect Name of the connection.
+ void nameConnectChanged(const QString &nameConnect);
+ /// The signal is emitted when a command is received.
+ /// @param command The received command.
+ void commandRecieved(const DapCommand &command);
+ /// The signal is emitted when sending a command.
+ /// @param command Submitted command.
+ void commandSent(const DapCommand &command);
+};
+
+#endif // DAPLOCALSERVER_H
diff --git a/libKelvinDashboardCommon/libKelvinDashboardCommon.pri b/libKelvinDashboardCommon/libKelvinDashboardCommon.pri
new file mode 100644
index 0000000000000000000000000000000000000000..babffc9bf13edec1868c857f88b033324eda6643
--- /dev/null
+++ b/libKelvinDashboardCommon/libKelvinDashboardCommon.pri
@@ -0,0 +1,22 @@
+#-------------------------------------------------
+#
+# Project created by QtCreator 2018-09-25T15:52:05
+#
+#-------------------------------------------------
+
+# You can also make your code fail to compile if you use deprecated APIs.
+# In order to do so, uncomment the following line.
+# You can also select to disable deprecated APIs only up to a certain version of Qt.
+#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0
+
+SOURCES +=\
+ $$PWD/DapCommand.cpp \
+ $$PWD/DapLocalServer.cpp \
+ $$PWD/DapLocalClient.cpp \
+ $$PWD/DapHalper.cpp
+
+HEADERS +=\
+ $$PWD/DapCommand.h \
+ $$PWD/DapLocalServer.h \
+ $$PWD/DapLocalClient.h \
+ $$PWD/DapHalper.h