From 3ca2994e5f1614a6cd082cfb7d056384c1804c2a Mon Sep 17 00:00:00 2001
From: "Dmitriy A. Gerasimov" <dmitriy.gerasimov@demlabs.net>
Date: Fri, 17 Apr 2020 15:51:49 +0700
Subject: [PATCH] [+] Headless Qt files for wallets ops
---
DapChainConvertor.cpp | 28 ++
DapChainConvertor.h | 20 +
DapHistoryType.cpp | 47 +++
DapHistoryType.h | 60 +++
DapLogMessage.cpp | 57 +++
DapLogMessage.h | 89 ++++
DapNodeType.h | 60 +++
DapWallet.cpp | 203 +++++++++
DapWallet.h | 75 ++++
DapWalletHistoryEvent.cpp | 113 +++++
DapWalletHistoryEvent.h | 57 +++
DapWalletToken.cpp | 113 +++++
DapWalletToken.h | 61 +++
dapRPCProtocol/DapRPCProtocol.pri | 25 ++
dapRPCProtocol/DapRpcAbstractServer.cpp | 31 ++
dapRPCProtocol/DapRpcAbstractServer.h | 54 +++
dapRPCProtocol/DapRpcLocalServer.cpp | 113 +++++
dapRPCProtocol/DapRpcLocalServer.h | 78 ++++
dapRPCProtocol/DapRpcMessage.cpp | 391 ++++++++++++++++++
dapRPCProtocol/DapRpcMessage.h | 183 ++++++++
dapRPCProtocol/DapRpcService.cpp | 351 ++++++++++++++++
dapRPCProtocol/DapRpcService.h | 75 ++++
dapRPCProtocol/DapRpcServiceProvider.cpp | 107 +++++
dapRPCProtocol/DapRpcServiceProvider.h | 51 +++
dapRPCProtocol/DapRpcServiceReply.cpp | 31 ++
dapRPCProtocol/DapRpcServiceReply.h | 48 +++
dapRPCProtocol/DapRpcServiceRequest.cpp | 69 ++++
dapRPCProtocol/DapRpcServiceRequest.h | 60 +++
dapRPCProtocol/DapRpcSocket.cpp | 266 ++++++++++++
dapRPCProtocol/DapRpcSocket.h | 157 +++++++
dapRPCProtocol/DapRpcTCPServer.cpp | 110 +++++
dapRPCProtocol/DapRpcTCPServer.h | 76 ++++
handlers/DapAbstractCommand.cpp | 232 +++++++++++
handlers/DapAbstractCommand.h | 138 +++++++
handlers/DapActivateClientCommand.cpp | 13 +
handlers/DapActivateClientCommand.h | 28 ++
handlers/DapAddWalletCommand.cpp | 46 +++
handlers/DapAddWalletCommand.h | 38 ++
handlers/DapCreateTransactionCommand.cpp | 51 +++
handlers/DapCreateTransactionCommand.h | 35 ++
handlers/DapExportLogCommand.cpp | 42 ++
handlers/DapExportLogCommand.h | 30 ++
handlers/DapGetHistoryExecutedCmdCommand.cpp | 48 +++
handlers/DapGetHistoryExecutedCmdCommand.h | 35 ++
handlers/DapGetListNetworksCommand.cpp | 42 ++
handlers/DapGetListNetworksCommand.h | 30 ++
handlers/DapGetListWalletsCommand.cpp | 49 +++
handlers/DapGetListWalletsCommand.h | 34 ++
handlers/DapGetWalletAddressesCommand.cpp | 68 +++
handlers/DapGetWalletAddressesCommand.h | 38 ++
handlers/DapGetWalletHistoryCommand.cpp | 63 +++
handlers/DapGetWalletHistoryCommand.h | 38 ++
handlers/DapGetWalletInfoCommand.cpp | 107 +++++
handlers/DapGetWalletInfoCommand.h | 37 ++
handlers/DapGetWalletTokenInfoCommand.cpp | 53 +++
handlers/DapGetWalletTokenInfoCommand.h | 30 ++
handlers/DapGetWalletsInfoCommand.cpp | 121 ++++++
handlers/DapGetWalletsInfoCommand.h | 38 ++
handlers/DapMempoolProcessCommand.cpp | 43 ++
handlers/DapMempoolProcessCommand.h | 32 ++
handlers/DapQuitApplicationCommand.cpp | 50 +++
handlers/DapQuitApplicationCommand.h | 50 +++
handlers/DapRunCmdCommand.cpp | 42 ++
handlers/DapRunCmdCommand.h | 31 ++
handlers/DapSaveHistoryExecutedCmdCommand.cpp | 42 ++
handlers/DapSaveHistoryExecutedCmdCommand.h | 34 ++
handlers/DapUpdateLogsCommand.cpp | 132 ++++++
handlers/DapUpdateLogsCommand.h | 58 +++
libdap-qt-ui-chain-wallet.pri | 81 ++++
models/DapWalletModel.cpp | 129 ++++++
models/DapWalletModel.h | 57 +++
serviceClient/DapServiceClient.cpp | 150 +++++++
serviceClient/DapServiceClient.h | 93 +++++
.../DapServiceClientNativeAbstract.cpp | 54 +++
.../DapServiceClientNativeAbstract.h | 41 ++
serviceClient/DapServiceClientNativeLinux.cpp | 76 ++++
serviceClient/DapServiceClientNativeLinux.h | 21 +
serviceClient/DapServiceClientNativeMacOS.cpp | 76 ++++
serviceClient/DapServiceClientNativeMacOS.h | 21 +
serviceClient/DapServiceClientNativeWin.cpp | 31 ++
serviceClient/DapServiceClientNativeWin.h | 19 +
81 files changed, 6106 insertions(+)
create mode 100644 DapChainConvertor.cpp
create mode 100644 DapChainConvertor.h
create mode 100644 DapHistoryType.cpp
create mode 100644 DapHistoryType.h
create mode 100644 DapLogMessage.cpp
create mode 100644 DapLogMessage.h
create mode 100644 DapNodeType.h
create mode 100644 DapWallet.cpp
create mode 100644 DapWallet.h
create mode 100644 DapWalletHistoryEvent.cpp
create mode 100644 DapWalletHistoryEvent.h
create mode 100644 DapWalletToken.cpp
create mode 100644 DapWalletToken.h
create mode 100644 dapRPCProtocol/DapRPCProtocol.pri
create mode 100644 dapRPCProtocol/DapRpcAbstractServer.cpp
create mode 100644 dapRPCProtocol/DapRpcAbstractServer.h
create mode 100644 dapRPCProtocol/DapRpcLocalServer.cpp
create mode 100644 dapRPCProtocol/DapRpcLocalServer.h
create mode 100644 dapRPCProtocol/DapRpcMessage.cpp
create mode 100644 dapRPCProtocol/DapRpcMessage.h
create mode 100644 dapRPCProtocol/DapRpcService.cpp
create mode 100644 dapRPCProtocol/DapRpcService.h
create mode 100644 dapRPCProtocol/DapRpcServiceProvider.cpp
create mode 100644 dapRPCProtocol/DapRpcServiceProvider.h
create mode 100644 dapRPCProtocol/DapRpcServiceReply.cpp
create mode 100644 dapRPCProtocol/DapRpcServiceReply.h
create mode 100644 dapRPCProtocol/DapRpcServiceRequest.cpp
create mode 100644 dapRPCProtocol/DapRpcServiceRequest.h
create mode 100644 dapRPCProtocol/DapRpcSocket.cpp
create mode 100644 dapRPCProtocol/DapRpcSocket.h
create mode 100644 dapRPCProtocol/DapRpcTCPServer.cpp
create mode 100644 dapRPCProtocol/DapRpcTCPServer.h
create mode 100644 handlers/DapAbstractCommand.cpp
create mode 100644 handlers/DapAbstractCommand.h
create mode 100644 handlers/DapActivateClientCommand.cpp
create mode 100644 handlers/DapActivateClientCommand.h
create mode 100644 handlers/DapAddWalletCommand.cpp
create mode 100644 handlers/DapAddWalletCommand.h
create mode 100644 handlers/DapCreateTransactionCommand.cpp
create mode 100644 handlers/DapCreateTransactionCommand.h
create mode 100644 handlers/DapExportLogCommand.cpp
create mode 100644 handlers/DapExportLogCommand.h
create mode 100644 handlers/DapGetHistoryExecutedCmdCommand.cpp
create mode 100644 handlers/DapGetHistoryExecutedCmdCommand.h
create mode 100644 handlers/DapGetListNetworksCommand.cpp
create mode 100644 handlers/DapGetListNetworksCommand.h
create mode 100644 handlers/DapGetListWalletsCommand.cpp
create mode 100644 handlers/DapGetListWalletsCommand.h
create mode 100644 handlers/DapGetWalletAddressesCommand.cpp
create mode 100644 handlers/DapGetWalletAddressesCommand.h
create mode 100644 handlers/DapGetWalletHistoryCommand.cpp
create mode 100644 handlers/DapGetWalletHistoryCommand.h
create mode 100644 handlers/DapGetWalletInfoCommand.cpp
create mode 100644 handlers/DapGetWalletInfoCommand.h
create mode 100644 handlers/DapGetWalletTokenInfoCommand.cpp
create mode 100644 handlers/DapGetWalletTokenInfoCommand.h
create mode 100644 handlers/DapGetWalletsInfoCommand.cpp
create mode 100644 handlers/DapGetWalletsInfoCommand.h
create mode 100644 handlers/DapMempoolProcessCommand.cpp
create mode 100644 handlers/DapMempoolProcessCommand.h
create mode 100644 handlers/DapQuitApplicationCommand.cpp
create mode 100644 handlers/DapQuitApplicationCommand.h
create mode 100644 handlers/DapRunCmdCommand.cpp
create mode 100644 handlers/DapRunCmdCommand.h
create mode 100644 handlers/DapSaveHistoryExecutedCmdCommand.cpp
create mode 100644 handlers/DapSaveHistoryExecutedCmdCommand.h
create mode 100644 handlers/DapUpdateLogsCommand.cpp
create mode 100644 handlers/DapUpdateLogsCommand.h
create mode 100644 libdap-qt-ui-chain-wallet.pri
create mode 100644 models/DapWalletModel.cpp
create mode 100644 models/DapWalletModel.h
create mode 100644 serviceClient/DapServiceClient.cpp
create mode 100644 serviceClient/DapServiceClient.h
create mode 100644 serviceClient/DapServiceClientNativeAbstract.cpp
create mode 100644 serviceClient/DapServiceClientNativeAbstract.h
create mode 100644 serviceClient/DapServiceClientNativeLinux.cpp
create mode 100644 serviceClient/DapServiceClientNativeLinux.h
create mode 100644 serviceClient/DapServiceClientNativeMacOS.cpp
create mode 100644 serviceClient/DapServiceClientNativeMacOS.h
create mode 100644 serviceClient/DapServiceClientNativeWin.cpp
create mode 100644 serviceClient/DapServiceClientNativeWin.h
diff --git a/DapChainConvertor.cpp b/DapChainConvertor.cpp
new file mode 100644
index 00000000..34d7d318
--- /dev/null
+++ b/DapChainConvertor.cpp
@@ -0,0 +1,28 @@
+#include "DapChainConvertor.h"
+
+DapChainConvertor::DapChainConvertor(QObject *parent) : QObject(parent)
+{
+
+}
+
+DapChainConvertor& DapChainConvertor::getInstance()
+{
+ static DapChainConvertor instance;
+ return instance;
+}
+
+QString DapChainConvertor::toConvertCurrency(const QString& aMoney)
+{
+ QString money;
+
+ QStringList major = aMoney.split(".");
+ if(!major.isEmpty()) money = major.at(0);
+ else money = aMoney;
+
+ for (int i = money.size() - 3; i >= 1; i -= 3)
+ money.insert(i, ' ');
+
+ if(major.count() > 1) money.append("." + major.at(1));
+
+ return money;
+}
diff --git a/DapChainConvertor.h b/DapChainConvertor.h
new file mode 100644
index 00000000..25dcd861
--- /dev/null
+++ b/DapChainConvertor.h
@@ -0,0 +1,20 @@
+#ifndef DAPCHAINCONVERTOR_H
+#define DAPCHAINCONVERTOR_H
+
+#include <QObject>
+
+class DapChainConvertor : public QObject
+{
+ Q_OBJECT
+
+public:
+ explicit DapChainConvertor(QObject *parent = nullptr);
+ /// Get instance of this class
+ /// @param instance of this class
+ static DapChainConvertor &getInstance();
+
+public slots:
+ Q_INVOKABLE QString toConvertCurrency(const QString& aMoney);
+};
+
+#endif // DAPCHAINCONVERTOR_H
diff --git a/DapHistoryType.cpp b/DapHistoryType.cpp
new file mode 100644
index 00000000..0eec6f63
--- /dev/null
+++ b/DapHistoryType.cpp
@@ -0,0 +1,47 @@
+#include "DapHistoryType.h"
+
+const QMap<DapTransactionStatus, QStringList> DapTransactionStatusConvertor::m_statusMap =
+{
+ {stSent, QStringList() << "send" << "Sent" << "#959CA6"},
+ {stReceived, QStringList() << "recv" << "Received" << "#454E63"},
+};
+
+QString DapTransactionStatusConvertor::getShortStatus(const DapTransactionStatus aStatus)
+{
+ if(!m_statusMap.contains(aStatus)) return QString();
+ return m_statusMap[aStatus].at(0);
+}
+
+QString DapTransactionStatusConvertor::getLongStatus(const DapTransactionStatus aStatus)
+{
+ if(!m_statusMap.contains(aStatus)) return QString();
+ return m_statusMap[aStatus].at(1);
+}
+
+DapTransactionStatus DapTransactionStatusConvertor::getStatusByShort(const QString& aShortStatus)
+{
+ for(auto item = m_statusMap.constBegin(); item != m_statusMap.constEnd(); item++)
+ {
+ if(item.value().at(0) == aShortStatus)
+ return item.key();
+ }
+
+ return stUnknow;
+}
+
+DapTransactionStatus DapTransactionStatusConvertor::getStatusByLong(const QString& aLongStatus)
+{
+ for(auto item = m_statusMap.constBegin(); item != m_statusMap.constEnd(); item++)
+ {
+ if(item.value().at(1) == aLongStatus)
+ return item.key();
+ }
+
+ return stUnknow;
+}
+
+QColor DapTransactionStatusConvertor::getStatusColor(const DapTransactionStatus aStatus)
+{
+ if(!m_statusMap.contains(aStatus)) return QColor();
+ return QColor(m_statusMap[aStatus].at(2));
+}
diff --git a/DapHistoryType.h b/DapHistoryType.h
new file mode 100644
index 00000000..cdd0b02c
--- /dev/null
+++ b/DapHistoryType.h
@@ -0,0 +1,60 @@
+#ifndef DAPHISTORYTYPE_H
+#define DAPHISTORYTYPE_H
+
+#include <QDateTime>
+#include <QImage>
+#include <QMap>
+#include <QStringList>
+
+/// Enumeration of transaction status
+enum DapTransactionStatus {
+ stUnknow,
+ stPending,
+ stSent,
+ stReceived,
+ stError
+};
+
+/// Structure for transaction item
+struct DapTransactionItem {
+ QDateTime Date;
+ QImage TokenPic;
+ DapTransactionStatus Status;
+ QString TokenName;
+ QString WalletNumber;
+ QString Cryptocurrency;
+ QString Currency;
+};
+
+/// Class-convertor transaction status
+/// @todo This class does not have all statuses
+class DapTransactionStatusConvertor
+{
+
+private:
+ static const QMap<DapTransactionStatus, QStringList> m_statusMap;
+
+public:
+ /// Get short text of status. CLI uses short text of transaction
+ /// @param enum status of transaction
+ /// @return short text of status
+ static QString getShortStatus(const DapTransactionStatus aStatus);
+ /// Get long text of status. Client uses long text of status
+ /// @param enum status of transaction
+ /// @return long text of status
+ static QString getLongStatus(const DapTransactionStatus aStatus);
+ /// Get enum status tranaction by short text of status tranasction
+ /// @param short text of trasaction
+ /// @return enum status of tranaction
+ static DapTransactionStatus getStatusByShort(const QString& aShortStatus);
+ /// Get enum status of tranaction by long text of transaction
+ /// @param long text of transaction
+ /// @return enum status of transaction
+ static DapTransactionStatus getStatusByLong(const QString& aLongStatus);
+ /// Get color for status of transaction
+ /// @param enum status of transaction
+ /// @return color for status of transaction
+ static QColor getStatusColor(const DapTransactionStatus aStatus);
+};
+
+#endif // DAPHISTORYTYPE_H
diff --git a/DapLogMessage.cpp b/DapLogMessage.cpp
new file mode 100644
index 00000000..98994380
--- /dev/null
+++ b/DapLogMessage.cpp
@@ -0,0 +1,57 @@
+#include "DapLogMessage.h"
+
+DapLogMessage::DapLogMessage(const QString &asType, const QString &asTimestamp, const QString &asFile, const QString &asMessage, QObject *parent) : QObject(parent)
+{
+ m_type = asType;
+ m_sTimeStamp = asTimestamp;
+ m_sFile = asFile;
+ m_sMessage = asMessage;
+}
+
+QString DapLogMessage::getType() const
+{
+ return m_type;
+}
+
+void DapLogMessage::setType(const QString &asType)
+{
+ m_type = asType;
+
+ emit typeChanged(m_type);
+}
+
+QString DapLogMessage::getTimeStamp() const
+{
+ return m_sTimeStamp;
+}
+
+void DapLogMessage::setTimeStamp(const QString &asTimeStamp)
+{
+ m_sTimeStamp = asTimeStamp;
+
+ emit timeStampChanged(m_sTimeStamp);
+}
+
+QString DapLogMessage::getFile() const
+{
+ return m_sFile;
+}
+
+void DapLogMessage::setFile(const QString &asFile)
+{
+ m_sFile = asFile;
+
+ emit fileChanged(m_sFile);
+}
+
+QString DapLogMessage::getMessage() const
+{
+ return m_sMessage;
+}
+
+void DapLogMessage::setMessage(const QString &asMessage)
+{
+ m_sMessage = asMessage;
+
+ emit messageChanged(m_sMessage);
+}
diff --git a/DapLogMessage.h b/DapLogMessage.h
new file mode 100644
index 00000000..ad6d5c34
--- /dev/null
+++ b/DapLogMessage.h
@@ -0,0 +1,89 @@
+#ifndef DAPLOGMESSAGE_H
+#define DAPLOGMESSAGE_H
+
+#include <QObject>
+
+// TODO: I think it's useless enum
+enum Type
+{
+ Info,
+ Warning,
+ Debug,
+ Error
+};
+
+class DapLogMessage : public QObject
+{
+ Q_OBJECT
+
+ /// type of log message
+ QString m_type;
+ /// timestamp
+ QString m_sTimeStamp;
+ /// name of file where log message was occur
+ QString m_sFile;
+ /// text of log message
+ QString m_sMessage;
+
+public:
+ /// standard constructor
+ explicit DapLogMessage(QObject *parent = nullptr) { Q_UNUSED(parent) }
+ /// overloaded constructor
+ /// @param asType Еype of log message
+ /// @param asTimestamp Timestamp of log message
+ /// @param asFile Name if file where log message was occur
+ /// @param asMessage Text of log message
+ DapLogMessage(const QString &asType, const QString &asTimestamp,
+ const QString &asFile, const QString &asMessage, QObject *parent = nullptr);
+
+
+ Q_PROPERTY(QString type READ getType WRITE setType NOTIFY typeChanged)
+ Q_PROPERTY(QString timestamp READ getTimeStamp WRITE setTimeStamp NOTIFY timeStampChanged)
+ Q_PROPERTY(QString file READ getFile WRITE setFile NOTIFY fileChanged)
+ Q_PROPERTY(QString message READ getMessage WRITE setMessage NOTIFY messageChanged)
+
+ /// Get type
+ /// @return Type of log message
+ QString getType() const;
+ /// Set type to message
+ /// @param asType Type of log message
+ void setType(const QString &asType);
+
+ /// Get timestamp
+ /// @return Timestamp of log message
+ QString getTimeStamp() const;
+ /// Set timestamp to log message
+ /// @param asTimeStamp Timestamp of log message
+ void setTimeStamp(const QString &asTimeStamp);
+
+ /// Get name of file
+ /// @return Name of file where log message was occur
+ QString getFile() const;
+ /// Set name of file
+ /// @param asFile Name of file
+ void setFile(const QString &asFile);
+
+ /// Get text of log message
+ /// @return Text of log message
+ QString getMessage() const;
+ /// Set text to log message
+ /// @param asMessage Text of log message
+ void setMessage(const QString &asMessage);
+
+signals:
+ /// The signal emitted in case when type of log message was changed
+ /// @param asType type of log message
+ void typeChanged(const QString& asType);
+ /// The signal emitted in case when timestamp of log message was changed
+ /// @param asTimeStamp Timestamp of log message
+ void timeStampChanged(const QString& asTimeStamp);
+ /// The signal emitted in case when file og log message was changed
+ /// @param asFile Name of log message was changed
+ void fileChanged(const QString& asFile);
+ /// The signal emitted in case when message was changed
+ /// @param asMessage Text of log message
+ void messageChanged(const QString& asMessage);
+
+};
+
+#endif // DAPLOGMESSAGE_H
diff --git a/DapNodeType.h b/DapNodeType.h
new file mode 100644
index 00000000..4dfaa833
--- /dev/null
+++ b/DapNodeType.h
@@ -0,0 +1,60 @@
+#ifndef DAPNODETYPE_H
+#define DAPNODETYPE_H
+
+#include <QString>
+#include <QStringList>
+#include <QDataStream>
+
+/// Structure for node network data
+struct DapNodeData {
+ quint32 Cell;
+ QString Ipv4;
+ QString Alias;
+ QStringList Link;
+ bool Status;
+ bool isCurrentNode;
+
+ DapNodeData()
+ {
+ Status = false;
+ isCurrentNode = false;
+ }
+
+ DapNodeData& operator = (const DapNodeData& AData) {
+ Cell = AData.Cell;
+ Alias = AData.Alias;
+ Ipv4 = AData.Ipv4;
+ Link = AData.Link;
+ Status = AData.Status;
+ isCurrentNode = AData.isCurrentNode;
+ return *this;
+ }
+
+ friend QDataStream& operator<< (QDataStream& out, const DapNodeData& aData)
+ {
+ out << aData.Cell
+ << aData.Ipv4
+ << aData.Alias
+ << aData.Link
+ << aData.Status
+ << aData.isCurrentNode;
+
+ return out;
+ }
+
+ friend QDataStream& operator>> (QDataStream& in, DapNodeData& aData)
+ {
+ in >> aData.Cell
+ >> aData.Ipv4
+ >> aData.Alias
+ >> aData.Link
+ >> aData.Status
+ >> aData.isCurrentNode;
+ return in;
+ }
+};
+
+typedef QMap<QString /*Address*/, DapNodeData /*Data*/> DapNodeMap;
+
+
+#endif // DAPNODETYPE_H
diff --git a/DapWallet.cpp b/DapWallet.cpp
new file mode 100644
index 00000000..422cf709
--- /dev/null
+++ b/DapWallet.cpp
@@ -0,0 +1,203 @@
+#include "DapWallet.h"
+
+DapWallet::DapWallet(QObject * parent)
+ : QObject(parent)
+{
+
+}
+
+DapWallet::DapWallet(const DapWallet &aWallet)
+ : m_sName(aWallet.m_sName), m_dBalance(aWallet.m_dBalance), m_sIcon(aWallet.m_sIcon), m_sAddress(aWallet.m_sAddress),
+ m_aNetworks(aWallet.m_aNetworks), m_aAddresses(aWallet.m_aAddresses), m_aTokens(aWallet.m_aTokens)
+{
+
+}
+
+DapWallet &DapWallet::operator=(const DapWallet &aWallet)
+{
+ m_sName = aWallet.m_sName;
+ m_dBalance = aWallet.m_dBalance;
+ m_sIcon = aWallet.m_sIcon;
+ m_sAddress = aWallet.m_sAddress;
+ m_aNetworks = aWallet.m_aNetworks;
+ m_aAddresses = aWallet.m_aAddresses;
+ m_aTokens = aWallet.m_aTokens;
+ return (*this);
+}
+
+QString DapWallet::getName() const
+{
+ return m_sName;
+}
+
+void DapWallet::setName(const QString &asName)
+{
+ m_sName = asName;
+
+ emit nameChanged(m_sName);
+}
+
+double DapWallet::getBalance() const
+{
+ return m_dBalance;
+}
+
+void DapWallet::setBalance(const double& adBalance)
+{
+ m_dBalance = adBalance;
+
+ emit balanceChanged(m_dBalance);
+}
+
+QString DapWallet::getIcon() const
+{
+ return m_sIcon;
+}
+
+void DapWallet::setIcon(const QString &sIcon)
+{
+ m_sIcon = sIcon;
+
+ emit iconChanged(m_sIcon);
+}
+
+void DapWallet::addNetwork(const QString &asNetwork)
+{
+ m_aNetworks.append(asNetwork);
+
+ emit networkAdded(asNetwork);
+ emit networksChanged(m_aNetworks);
+}
+
+QStringList DapWallet::getNetworks() const
+{
+ return m_aNetworks;
+}
+
+void DapWallet::setAddress(const QString &asNetwork)
+{
+ m_sAddress = m_aAddresses.find(asNetwork).value();
+
+ emit addressChanged(m_sAddress);
+}
+
+QString DapWallet::getAddress() const
+{
+ return m_sAddress;
+}
+
+void DapWallet::addAddress(const QString& aiAddress, const QString &asNetwork)
+{
+ m_aAddresses.insert(asNetwork, aiAddress);
+}
+
+QString DapWallet::findAddress(const QString &asNetwork) const
+{
+ if(asNetwork.isNull() || asNetwork.isNull())
+ return QString();
+
+ QString s=m_aAddresses.find(asNetwork).value();
+ return m_aAddresses.find(asNetwork) != m_aAddresses.end() ? m_aAddresses.find(asNetwork).value() : QString();
+}
+
+QMap<QString, QString> DapWallet::getAddresses() const
+{
+ return m_aAddresses;
+}
+
+void DapWallet::addToken(DapWalletToken *asToken)
+{
+ m_aTokens.append(asToken);
+
+ emit tokenAdded(*asToken);
+
+ QList<QObject*> tokens;
+ auto begin = m_aTokens.begin();
+ auto end = m_aTokens.end();
+ for(;begin != end; ++begin)
+ {
+ tokens.append(*begin);
+ }
+ emit tokensChanged(tokens);
+}
+
+QList<DapWalletToken*> DapWallet::findTokens(const QString &asNetwork)
+{
+ QList<DapWalletToken*> tokens;
+ auto begin = m_aTokens.begin();
+ auto end = m_aTokens.end();
+ for(;begin != end; ++begin)
+ {
+ if((*begin)->getNetwork() == asNetwork)
+ {
+ tokens.append(*begin);
+ }
+ }
+ return tokens;
+}
+
+QList<QObject *> DapWallet::getTokens() const
+{
+ QList<QObject*> tokens;
+ auto begin = m_aTokens.begin();
+ auto end = m_aTokens.end();
+ for(;begin != end; ++begin)
+ {
+ tokens.append(*begin);
+ }
+ return tokens;
+}
+
+DapWallet DapWallet::fromVariant(const QVariant &aWallet)
+{
+ DapWallet wallet;
+ QByteArray data = QByteArray::fromStdString(aWallet.toString().toStdString());
+ QDataStream in(&data, QIODevice::ReadOnly);
+ in >> wallet;
+ return wallet;
+}
+
+QDataStream& operator << (QDataStream& aOut, const DapWallet& aWallet)
+{
+ QList<DapWalletToken> tokens;
+ for(int x{0}; x < aWallet.m_aTokens.size(); ++x)
+ {
+ tokens.append(*aWallet.m_aTokens.at(x));
+ }
+
+ aOut << aWallet.m_sName
+ << aWallet.m_dBalance
+ << aWallet.m_sIcon
+ << aWallet.m_sAddress
+ << aWallet.m_aNetworks
+ << aWallet.m_aAddresses
+ << tokens;
+
+ return aOut;
+}
+
+QDataStream& operator >> (QDataStream& aIn, DapWallet& aWallet)
+{
+ QList<DapWalletToken> tokens;
+
+ aIn >> aWallet.m_sName;
+ aIn.setFloatingPointPrecision(QDataStream::DoublePrecision);
+ aIn >> aWallet.m_dBalance
+ >> aWallet.m_sIcon
+ >> aWallet.m_sAddress
+ >> aWallet.m_aNetworks
+ >> aWallet.m_aAddresses
+ >> tokens;
+
+
+ auto begin = tokens.begin();
+ auto end = tokens.end();
+ for(;begin != end; ++begin)
+ aWallet.addToken(new DapWalletToken(*begin));
+ return aIn;
+}
+
+bool operator ==(const DapWallet &aWalletFirst, const DapWallet &aWalletSecond)
+{
+ return aWalletFirst.m_sName == aWalletSecond.m_sName;
+}
diff --git a/DapWallet.h b/DapWallet.h
new file mode 100644
index 00000000..1cdcf71c
--- /dev/null
+++ b/DapWallet.h
@@ -0,0 +1,75 @@
+#ifndef DAPWALLET_H
+#define DAPWALLET_H
+
+#include <QObject>
+#include <QString>
+#include <QList>
+#include <QQmlEngine>
+
+#include "DapWalletToken.h"
+
+class DapWallet : public QObject
+{
+ Q_OBJECT
+
+ QString m_sName;
+ double m_dBalance {0.0};
+ QString m_sIcon;
+ QString m_sAddress = "private";
+ QStringList m_aNetworks;
+ QMap<QString, QString> m_aAddresses;
+ mutable QList<DapWalletToken*> m_aTokens;
+
+public:
+ Q_INVOKABLE explicit DapWallet(QObject * parent = nullptr);
+ Q_INVOKABLE DapWallet(const DapWallet& aWallet);
+ Q_INVOKABLE DapWallet& operator=(const DapWallet& aToken);
+
+
+ Q_PROPERTY(QString Name MEMBER m_sName READ getName WRITE setName NOTIFY nameChanged)
+ Q_PROPERTY(double Balance MEMBER m_dBalance READ getBalance WRITE setBalance NOTIFY balanceChanged)
+ Q_PROPERTY(QString Icon MEMBER m_sIcon READ getIcon WRITE setIcon NOTIFY iconChanged)
+ Q_PROPERTY(QString Address MEMBER m_sAddress READ getAddress NOTIFY addressChanged)
+ Q_PROPERTY(QStringList Networks MEMBER m_aNetworks READ getNetworks NOTIFY networksChanged)
+ Q_PROPERTY(QList<QObject*> Tokens READ getTokens NOTIFY tokensChanged)
+
+
+ friend QDataStream& operator << (QDataStream& aOut, const DapWallet& aToken);
+ friend QDataStream& operator >> (QDataStream& aOut, DapWallet& aToken);
+ friend bool operator == (const DapWallet &aWalletFirst, const DapWallet &aWalletSecond);
+
+ static DapWallet fromVariant(const QVariant& aWallet);
+
+signals:
+ void nameChanged(const QString& asName);
+ void balanceChanged(const double& adBalance);
+ void iconChanged(const QString &asIcon);
+ void addressChanged(const QString& asAddress);
+ void networkAdded(const QString& asNetwork);
+ void networksChanged(const QStringList& asNetworks);
+ void tokensChanged(const QList<QObject*> asTokens);
+ void tokenAdded(const DapWalletToken& asNetwork);
+
+public slots:
+ QString getName() const;
+ void setName(const QString &asName);
+ double getBalance() const;
+ void setBalance(const double& adBalance);
+ QString getIcon() const;
+ void setIcon(const QString &sIcon);
+ void addNetwork(const QString& asNetwork);
+ QStringList getNetworks() const;
+ Q_INVOKABLE void setAddress(const QString& asNetwork);
+ QString getAddress() const;
+ void addAddress(const QString &aiAddress, const QString& asNetwork);
+ Q_INVOKABLE QString findAddress(const QString &asNetwork) const;
+ QMap<QString, QString> getAddresses() const;
+ void addToken(DapWalletToken *asToken);
+ Q_INVOKABLE QList<DapWalletToken*> findTokens(const QString& asNetwork);
+ Q_INVOKABLE QList<QObject*> getTokens() const;
+};
+
+Q_DECLARE_METATYPE(DapWallet)
+
+
+#endif // DAPWALLET_H
diff --git a/DapWalletHistoryEvent.cpp b/DapWalletHistoryEvent.cpp
new file mode 100644
index 00000000..e56e1502
--- /dev/null
+++ b/DapWalletHistoryEvent.cpp
@@ -0,0 +1,113 @@
+#include "DapWalletHistoryEvent.h"
+
+DapWalletHistoryEvent::DapWalletHistoryEvent(QObject *parent) : QObject(parent)
+{
+
+}
+
+DapWalletHistoryEvent::DapWalletHistoryEvent(const DapWalletHistoryEvent &aHistoryEvent)
+ : QObject(aHistoryEvent.parent()),m_sWallet(aHistoryEvent.m_sWallet), m_sName(aHistoryEvent.m_sName), m_sStatus(aHistoryEvent.m_sStatus),
+ m_dAmount(aHistoryEvent.m_dAmount), m_sDate(aHistoryEvent.m_sDate)
+{
+
+}
+
+DapWalletHistoryEvent &DapWalletHistoryEvent::operator=(const DapWalletHistoryEvent &aHistoryEvent)
+{
+ m_sWallet = aHistoryEvent.m_sWallet;
+ m_sName = aHistoryEvent.m_sName;
+ m_sStatus = aHistoryEvent.m_sStatus;
+ m_dAmount = aHistoryEvent.m_dAmount;
+ m_sDate = aHistoryEvent.m_sDate;
+ return (*this);
+}
+
+bool DapWalletHistoryEvent::operator==(const DapWalletHistoryEvent &aHistoryEvent) const
+{
+ return (m_sWallet == aHistoryEvent.m_sWallet)
+ && (m_sName == aHistoryEvent.m_sName)
+ && (m_sStatus == aHistoryEvent.m_sStatus)
+ && (m_dAmount == aHistoryEvent.m_dAmount)
+ && (m_sDate == aHistoryEvent.m_sDate);
+}
+
+QString DapWalletHistoryEvent::getWallet() const
+{
+ return m_sWallet;
+}
+
+void DapWalletHistoryEvent::setWallet(const QString &sWallet)
+{
+ m_sWallet = sWallet;
+
+ emit walletChanged(m_sWallet);
+}
+
+QString DapWalletHistoryEvent::getName() const
+{
+ return m_sName;
+}
+
+void DapWalletHistoryEvent::setName(const QString &sName)
+{
+ m_sName = sName;
+
+ emit nameChanged(m_sName);
+}
+
+double DapWalletHistoryEvent::getAmount() const
+{
+ return m_dAmount;
+}
+
+void DapWalletHistoryEvent::setAmount(double dAmount)
+{
+ m_dAmount = dAmount;
+
+ emit amountChanged(m_dAmount);
+}
+
+QString DapWalletHistoryEvent::getStatus() const
+{
+ return m_sStatus;
+}
+
+void DapWalletHistoryEvent::setStatus(const QString &sStatus)
+{
+ m_sStatus = sStatus;
+
+ emit statusChanged(m_sStatus);
+}
+
+QString DapWalletHistoryEvent::getDate() const
+{
+ return m_sDate;
+}
+
+void DapWalletHistoryEvent::setDate(const QString &sDate)
+{
+ m_sDate = sDate;
+
+ emit dateChanged(m_sDate);
+}
+
+QDataStream& operator << (QDataStream& aOut, const DapWalletHistoryEvent& aHistoryEvent)
+{
+ aOut << aHistoryEvent.m_sWallet
+ << aHistoryEvent.m_sName
+ << aHistoryEvent.m_dAmount
+ << aHistoryEvent.m_sStatus
+ << aHistoryEvent.m_sDate;
+ return aOut;
+}
+
+QDataStream& operator >> (QDataStream& aOut, DapWalletHistoryEvent& aHistoryEvent)
+{
+ aOut >> aHistoryEvent.m_sWallet
+ >> aHistoryEvent.m_sName;
+ aOut.setFloatingPointPrecision(QDataStream::DoublePrecision);
+ aOut >> aHistoryEvent.m_dAmount;
+ aOut >> aHistoryEvent.m_sStatus
+ >> aHistoryEvent.m_sDate;
+ return aOut;
+}
diff --git a/DapWalletHistoryEvent.h b/DapWalletHistoryEvent.h
new file mode 100644
index 00000000..5e6c1b45
--- /dev/null
+++ b/DapWalletHistoryEvent.h
@@ -0,0 +1,57 @@
+#ifndef DAPWALLETHISTORYEVENT_H
+#define DAPWALLETHISTORYEVENT_H
+
+#include <QObject>
+#include <QString>
+#include <QDataStream>
+
+class DapWalletHistoryEvent : public QObject
+{
+ Q_OBJECT
+
+ QString m_sWallet;
+ /// Token name.
+ QString m_sName;
+ /// Token balance.
+ QString m_sStatus;
+
+ double m_dAmount {0.0};
+
+ QString m_sDate;
+
+public:
+ explicit DapWalletHistoryEvent(QObject *parent = nullptr);
+ DapWalletHistoryEvent(const DapWalletHistoryEvent& aHistoryEvent);
+ DapWalletHistoryEvent& operator=(const DapWalletHistoryEvent& aHistoryEvent);
+ bool operator==(const DapWalletHistoryEvent& aHistoryEvent) const;
+
+ Q_PROPERTY(QString Wallet MEMBER m_sWallet READ getWallet WRITE setWallet NOTIFY walletChanged)
+ Q_PROPERTY(QString Name MEMBER m_sName READ getName WRITE setName NOTIFY nameChanged)
+ Q_PROPERTY(double Amount MEMBER m_dAmount READ getAmount WRITE setAmount NOTIFY amountChanged)
+ Q_PROPERTY(QString Status MEMBER m_sName READ getStatus WRITE setStatus NOTIFY statusChanged)
+ Q_PROPERTY(QString Date MEMBER m_dAmount READ getDate WRITE setDate NOTIFY dateChanged)
+
+ friend QDataStream& operator << (QDataStream& aOut, const DapWalletHistoryEvent& aHistoryEvent);
+ friend QDataStream& operator >> (QDataStream& aOut, DapWalletHistoryEvent& aHistoryEvent);
+
+signals:
+ void walletChanged(const QString& asWallet);
+ void nameChanged(const QString& asName);
+ void amountChanged(const double& adAmount);
+ void statusChanged(const QString& asStatus);
+ void dateChanged(const QString& asDate);
+
+public slots:
+ QString getWallet() const;
+ void setWallet(const QString &sWallet);
+ QString getName() const;
+ void setName(const QString &sName);
+ double getAmount() const;
+ void setAmount(double dAmount);
+ QString getStatus() const;
+ void setStatus(const QString &sStatus);
+ QString getDate() const;
+ void setDate(const QString &sDate);
+};
+
+#endif // DAPWALLETHISTORYEVENT_H
diff --git a/DapWalletToken.cpp b/DapWalletToken.cpp
new file mode 100644
index 00000000..beb3c270
--- /dev/null
+++ b/DapWalletToken.cpp
@@ -0,0 +1,113 @@
+#include "DapWalletToken.h"
+
+DapWalletToken::DapWalletToken(const QString &asName, QObject *parent)
+ : QObject(parent), m_sName(asName)
+{
+
+}
+
+DapWalletToken::DapWalletToken(const DapWalletToken &aToken)
+ : QObject(aToken.parent()), m_sName(aToken.m_sName), m_dBalance(aToken.m_dBalance),
+ m_iEmission(aToken.m_iEmission), m_sNetwork(aToken.m_sNetwork)
+{
+
+}
+
+DapWalletToken &DapWalletToken::operator=(const DapWalletToken &aToken)
+{
+ m_sName = aToken.m_sName;
+ m_dBalance = aToken.m_dBalance;
+ m_iEmission = aToken.m_iEmission;
+ m_sNetwork = aToken.m_sNetwork;
+ return (*this);
+}
+
+bool DapWalletToken::operator==(const DapWalletToken &aToken) const
+{
+ return m_sName == aToken.m_sName
+ && m_dBalance == aToken.m_dBalance
+ && m_iEmission == aToken.m_iEmission
+ && m_sNetwork == aToken.m_sNetwork;
+}
+
+QString DapWalletToken::getName() const
+{
+ return m_sName;
+}
+
+void DapWalletToken::setName(const QString &sName)
+{
+ m_sName = sName;
+
+ emit nameChanged(m_sName);
+}
+
+double DapWalletToken::getBalance() const
+{
+ return m_dBalance;
+}
+
+void DapWalletToken::setBalance(double dBalance)
+{
+ m_dBalance = dBalance;
+
+ emit balanceChanged(m_dBalance);
+}
+
+quint64 DapWalletToken::getEmission() const
+{
+ return m_iEmission;
+}
+
+void DapWalletToken::setEmission(const quint64 &iEmission)
+{
+ m_iEmission = iEmission;
+
+ emit emissionChanged(m_iEmission);
+}
+
+QString DapWalletToken::getNetwork() const
+{
+ return m_sNetwork;
+}
+
+void DapWalletToken::setNetwork(const QString &sNetwork)
+{
+ m_sNetwork = sNetwork;
+
+ emit networkChanged(m_sNetwork);
+}
+
+QString DapWalletToken::getIcon() const
+{
+ return m_sIcon;
+}
+
+void DapWalletToken::setIcon(const QString &sIcon)
+{
+ m_sIcon = sIcon;
+
+ emit iconChanged(m_sIcon);
+}
+
+QDataStream& operator << (QDataStream& aOut, const DapWalletToken& aToken)
+{
+ aOut << aToken.m_sName
+ << aToken.m_dBalance
+ << aToken.m_iEmission
+ << aToken.m_sNetwork;
+ return aOut;
+}
+
+QDataStream& operator >> (QDataStream& aOut, DapWalletToken& aToken)
+{
+ aOut >> aToken.m_sName;
+ aOut.setFloatingPointPrecision(QDataStream::DoublePrecision);
+ aOut >> aToken.m_dBalance;
+ aOut.setFloatingPointPrecision(QDataStream::SinglePrecision);
+ aOut >> aToken.m_iEmission
+ >> aToken.m_sNetwork;
+ return aOut;
+}
+
+
diff --git a/DapWalletToken.h b/DapWalletToken.h
new file mode 100644
index 00000000..5de45c4f
--- /dev/null
+++ b/DapWalletToken.h
@@ -0,0 +1,61 @@
+#ifndef DAPWALLETTOKEN_H
+#define DAPWALLETTOKEN_H
+
+#include <QObject>
+#include <QString>
+#include <QDataStream>
+
+class DapWalletToken : public QObject
+{
+ Q_OBJECT
+
+ /// Token name.
+ QString m_sName;
+ /// Token balance.
+ double m_dBalance {0.0};
+ /// Token emission.
+ quint64 m_iEmission {0};
+ /// Network.
+ QString m_sNetwork;
+ /// Icon path.
+ QString m_sIcon;
+
+public:
+ explicit DapWalletToken(const QString& asName = QString(), QObject *parent = nullptr);
+ DapWalletToken(const DapWalletToken& aToken);
+ DapWalletToken& operator=(const DapWalletToken& aToken);
+ bool operator==(const DapWalletToken& aToken) const;
+
+ Q_PROPERTY(QString Name MEMBER m_sName READ getName WRITE setName NOTIFY nameChanged)
+ Q_PROPERTY(double Balance MEMBER m_dBalance READ getBalance WRITE setBalance NOTIFY balanceChanged)
+ Q_PROPERTY(quint64 Emission MEMBER m_iEmission READ getEmission WRITE setEmission NOTIFY emissionChanged)
+ Q_PROPERTY(QString Network MEMBER m_sNetwork READ getNetwork WRITE setNetwork NOTIFY networkChanged)
+ Q_PROPERTY(QString Icon MEMBER m_sIcon READ getIcon WRITE setIcon NOTIFY iconChanged)
+
+
+ friend QDataStream& operator << (QDataStream& aOut, const DapWalletToken& aToken);
+ friend QDataStream& operator >> (QDataStream& aOut, DapWalletToken& aToken);
+
+signals:
+ void nameChanged(const QString & asName);
+ void balanceChanged(const double & adBalance);
+ void emissionChanged(const qint64& aiEmission);
+ void networkChanged(const QString &asNetwork);
+ void iconChanged(const QString &asIcon);
+
+public slots:
+ QString getName() const;
+ void setName(const QString &sName);
+ double getBalance() const;
+ void setBalance(double dBalance);
+ quint64 getEmission() const;
+ void setEmission(const quint64 &iEmission);
+ QString getNetwork() const;
+ void setNetwork(const QString &sNetwork);
+ QString getIcon() const;
+ void setIcon(const QString &sIcon);
+};
+
+Q_DECLARE_METATYPE(DapWalletToken)
+
+#endif // DAPWALLETTOKEN_H
diff --git a/dapRPCProtocol/DapRPCProtocol.pri b/dapRPCProtocol/DapRPCProtocol.pri
new file mode 100644
index 00000000..c6899ffa
--- /dev/null
+++ b/dapRPCProtocol/DapRPCProtocol.pri
@@ -0,0 +1,25 @@
+INCLUDEPATH += $$PWD
+
+HEADERS += \
+ $$PWD/DapRpcAbstractServer.h \
+ $$PWD/DapRpcLocalServer.h \
+ $$PWD/DapRpcMessage.h \
+ $$PWD/DapRpcService.h \
+ $$PWD/DapRpcServiceProvider.h \
+ $$PWD/DapRpcServiceReply.h \
+ $$PWD/DapRpcServiceRequest.h \
+ $$PWD/DapRpcSocket.h \
+ $$PWD/DapRpcTCPServer.h
+
+SOURCES += \
+ $$PWD/DapRpcAbstractServer.cpp \
+ $$PWD/DapRpcLocalServer.cpp \
+ $$PWD/DapRpcMessage.cpp \
+ $$PWD/DapRpcService.cpp \
+ $$PWD/DapRpcServiceProvider.cpp \
+ $$PWD/DapRpcServiceReply.cpp \
+ $$PWD/DapRpcServiceRequest.cpp \
+ $$PWD/DapRpcSocket.cpp \
+ $$PWD/DapRpcTCPServer.cpp
+
+
diff --git a/dapRPCProtocol/DapRpcAbstractServer.cpp b/dapRPCProtocol/DapRpcAbstractServer.cpp
new file mode 100644
index 00000000..025cf8ff
--- /dev/null
+++ b/dapRPCProtocol/DapRpcAbstractServer.cpp
@@ -0,0 +1,31 @@
+#include "DapRpcAbstractServer.h"
+
+DapRpcAbstractServer::DapRpcAbstractServer()
+{
+
+}
+
+DapRpcAbstractServer::~DapRpcAbstractServer()
+{
+
+}
+
+int DapRpcAbstractServer::connectedClientCount() const
+{
+ return m_clients.size();
+}
+
+DapRpcServiceReply* DapRpcAbstractServer::notifyConnectedClients(const DapRpcMessage &message)
+{
+ DapRpcServiceReply * reply {nullptr};
+ for (int i = 0; i < m_clients.size(); ++i)
+ reply = m_clients[i]->sendMessage(message);
+ return reply;
+}
+
+void DapRpcAbstractServer::notifyConnectedClients(const QString &method, const QJsonArray ¶ms)
+{
+ DapRpcMessage notification =
+ DapRpcMessage::createNotification(method, params);
+ notifyConnectedClients(notification);
+}
diff --git a/dapRPCProtocol/DapRpcAbstractServer.h b/dapRPCProtocol/DapRpcAbstractServer.h
new file mode 100644
index 00000000..b5d85122
--- /dev/null
+++ b/dapRPCProtocol/DapRpcAbstractServer.h
@@ -0,0 +1,54 @@
+#ifndef DapRPCABSTRACTSERVER_H
+#define DapRPCABSTRACTSERVER_H
+
+#include <QList>
+#include <QHostAddress>
+
+#include "DapRpcSocket.h"
+#include "DapRpcMessage.h"
+#include "DapRpcServiceProvider.h"
+
+/**
+ * @brief The DapRpcAbstractServer class
+ * Class of abstract RPC server. Include information about all clients
+ * Server can send/receive message to/from client by RPC protocol
+ */
+class DapRpcAbstractServer : public DapRpcServiceProvider
+{
+protected:
+ /// List of clients
+ QList<DapRpcSocket*> m_clients;
+
+public:
+ /// Standard constructor
+ DapRpcAbstractServer();
+ /// Virtual destructor
+ virtual ~DapRpcAbstractServer();
+ /// Connected clients count
+ /// @return Clients count
+ virtual int connectedClientCount() const;
+ /// Tells to server to listen incoming connections on address and port.
+ /// @param asAddress Address
+ /// @param aPort Port
+ /// @return If Server is currently listening then it will return false.
+ /// Otherwise return true.
+ virtual bool listen(const QString &asAddress = QString(), quint16 aPort = 0) = 0;
+// signals:
+ /// The signal is emitted when client was connected
+ virtual void onClientConnected() = 0;
+ /// The signal is emitted when client was disconnected
+ virtual void onClientDisconnected() = 0;
+
+// public slots:
+ /// Notify connected clients. Send all message
+ /// @param message Message to client
+ virtual DapRpcServiceReply *notifyConnectedClients(const DapRpcMessage &message);
+ /// Notify connected clients. Send all message
+ /// @param method Method which clients were notified
+ /// @param params Parameters of message in JSON format
+ virtual void notifyConnectedClients(const QString &method, const QJsonArray ¶ms);
+
+
+};
+
+#endif // DapRPCABSTRACTSERVER_H
diff --git a/dapRPCProtocol/DapRpcLocalServer.cpp b/dapRPCProtocol/DapRpcLocalServer.cpp
new file mode 100644
index 00000000..63b7e0e1
--- /dev/null
+++ b/dapRPCProtocol/DapRpcLocalServer.cpp
@@ -0,0 +1,113 @@
+#include "DapRpcLocalServer.h"
+
+DapRpcLocalServer::DapRpcLocalServer(QObject *apParent)
+ : QLocalServer(apParent)
+{
+ this->setSocketOptions(QLocalServer::WorldAccessOption);
+}
+
+DapRpcLocalServer::~DapRpcLocalServer()
+{
+ foreach (QLocalSocket *socket, m_socketLookup.keys()) {
+ socket->flush();
+ socket->deleteLater();
+ }
+ m_socketLookup.clear();
+
+ foreach (DapRpcSocket *client, m_clients)
+ client->deleteLater();
+ m_clients.clear();
+}
+
+bool DapRpcLocalServer::listen(const QString &asAddress, quint16 aPort)
+{
+ Q_UNUSED(aPort)
+
+ return QLocalServer::listen(asAddress);
+}
+
+DapRpcService *DapRpcLocalServer::addService(DapRpcService *apService)
+{
+ if (!DapRpcServiceProvider::addService(apService))
+ return nullptr;
+
+ connect(apService, SIGNAL(notifyConnectedClients(DapRpcMessage)),
+ this, SLOT(notifyConnectedClients(DapRpcMessage)));
+ connect(apService, SIGNAL(notifyConnectedClients(QString,QJsonArray)),
+ this, SLOT(notifyConnectedClients(QString,QJsonArray)));
+ return apService;
+}
+
+bool DapRpcLocalServer::removeService(DapRpcService *apService)
+{
+ if (!DapRpcServiceProvider::removeService(apService))
+ return false;
+
+ disconnect(apService, SIGNAL(notifyConnectedClients(DapRpcMessage)),
+ this, SLOT(notifyConnectedClients(DapRpcMessage)));
+ disconnect(apService, SIGNAL(notifyConnectedClients(QString,QJsonArray)),
+ this, SLOT(notifyConnectedClients(QString,QJsonArray)));
+ return true;
+}
+
+DapRpcService *DapRpcLocalServer::findService(const QString &asServiceName)
+{
+ return DapRpcServiceProvider::findService(asServiceName);
+}
+
+void DapRpcLocalServer::clientDisconnected()
+{
+ QLocalSocket *localSocket = static_cast<QLocalSocket*>(sender());
+ if (!localSocket) {
+ qJsonRpcDebug() << "called with invalid socket";
+ return;
+ }
+ if (m_socketLookup.contains(localSocket)) {
+ DapRpcSocket *socket = m_socketLookup.take(localSocket);
+ m_clients.removeAll(socket);
+ socket->deleteLater();
+ }
+
+ localSocket->deleteLater();
+ emit onClientDisconnected();
+}
+
+void DapRpcLocalServer::messageProcessing(const DapRpcMessage &asMessage)
+{
+ DapRpcSocket *socket = static_cast<DapRpcSocket*>(sender());
+ if (!socket) {
+ qJsonRpcDebug() << "called without service socket";
+ return;
+ }
+
+ processMessage(socket, asMessage);
+}
+
+DapRpcServiceReply *DapRpcLocalServer::notifyConnectedClients(const DapRpcMessage &message)
+{
+ return DapRpcAbstractServer::notifyConnectedClients(message);
+}
+
+void DapRpcLocalServer::notifyConnectedClients(const QString &method, const QJsonArray ¶ms)
+{
+ DapRpcAbstractServer::notifyConnectedClients(method, params);
+}
+
+void DapRpcLocalServer::incomingConnection(quintptr aSocketDescriptor)
+{
+ QLocalSocket *localSocket = new QLocalSocket(this);
+ if (!localSocket->setSocketDescriptor(aSocketDescriptor)) {
+ qJsonRpcDebug() << "nextPendingConnection is null";
+ localSocket->deleteLater();
+ return;
+ }
+
+ QIODevice *device = qobject_cast<QIODevice*>(localSocket);
+ DapRpcSocket *socket = new DapRpcSocket(device, this);
+ connect(socket, SIGNAL(messageReceived(DapRpcMessage)),
+ this, SLOT(messageProcessing(DapRpcMessage)));
+ m_clients.append(socket);
+ connect(localSocket, SIGNAL(disconnected()), this, SLOT(clientDisconnected()));
+ m_socketLookup.insert(localSocket, socket);
+ emit onClientConnected();
+}
diff --git a/dapRPCProtocol/DapRpcLocalServer.h b/dapRPCProtocol/DapRpcLocalServer.h
new file mode 100644
index 00000000..e72bf922
--- /dev/null
+++ b/dapRPCProtocol/DapRpcLocalServer.h
@@ -0,0 +1,78 @@
+#ifndef DapRPCLOCALSERVER_H
+#define DapRPCLOCALSERVER_H
+
+#include <QObject>
+#include <QLocalSocket>
+#include <QLocalServer>
+
+#include "DapRpcSocket.h"
+#include "DapRpcService.h"
+#include "DapRpcAbstractServer.h"
+
+/**
+ * @brief The DapRpcLocalServer class
+ * Local RPC server. inheritance from DapRpcAbstractServer
+ * @see DapRpcAbstractServer
+ * @see QLocalServer
+ */
+class DapRpcLocalServer : public QLocalServer, public DapRpcAbstractServer
+{
+ Q_OBJECT
+ Q_DISABLE_COPY(DapRpcLocalServer)
+
+ /// Hash map socket lookups. LocalSocket according to RPC socket
+ QHash<QLocalSocket*, DapRpcSocket*> m_socketLookup;
+
+protected:
+ /// Call when new connection is available
+ /// @param aSocketDescriptor SocketDescriptor is the native socket descriptor for the accepted connection
+ virtual void incomingConnection(quintptr aSocketDescriptor);
+
+public:
+ /// Standard constructor
+ explicit DapRpcLocalServer(QObject *apParent = nullptr);
+ /// Virtual overrided descriptor
+ virtual ~DapRpcLocalServer();
+
+ /// Tells to server to listen incoming connections on address and port.
+ /// @param asAddress Address
+ /// @param aPort Port
+ /// @return If Server is currently listening then it will return false.
+ /// Otherwise return true.
+ virtual bool listen(const QString &asAddress = QString(), quint16 aPort = 0);
+ /// Add new service
+ /// @param apService New service
+ /// @return If service add successfully return true. Otherwise return false
+ DapRpcService * addService(DapRpcService *apService);
+ /// Remove service
+ /// @param apService Service for removing
+ /// @return If service add successfully return true. Otherwise return false
+ bool removeService(DapRpcService *apService);
+
+
+ DapRpcService* findService(const QString& asServiceName);
+signals:
+ /// The signal is emitted when client was connected
+ void onClientConnected();
+ /// The signal is emitted when client was disconnected
+ void onClientDisconnected();
+
+private slots:
+ /// Calls when client disconnected
+ void clientDisconnected();
+ /// When receive message from client prepare message by type of message
+ /// @param asMessage Message
+ void messageProcessing(const DapRpcMessage &asMessage);
+
+ // DapRpcAbstractServer interface
+public slots:
+ /// Notify connected clients. Send all message
+ /// @param message Message to client
+ DapRpcServiceReply * notifyConnectedClients(const DapRpcMessage &message);
+ /// Notify connected clients. Send all message
+ /// @param method Method which clients were notified
+ /// @param params Parameters of message in JSON format
+ void notifyConnectedClients(const QString &method, const QJsonArray ¶ms);
+};
+
+#endif // DapRPCLOCALSERVER_H
diff --git a/dapRPCProtocol/DapRpcMessage.cpp b/dapRPCProtocol/DapRpcMessage.cpp
new file mode 100644
index 00000000..a2a83593
--- /dev/null
+++ b/dapRPCProtocol/DapRpcMessage.cpp
@@ -0,0 +1,391 @@
+#include "DapRpcMessage.h"
+
+class DapRpcMessagePrivate : public QSharedData
+{
+public:
+ DapRpcMessagePrivate();
+ ~DapRpcMessagePrivate();
+ DapRpcMessagePrivate(const DapRpcMessagePrivate &aDapRpcMessagePrivate);
+
+ void initializeWithObject(const QJsonObject &aMessage);
+ static DapRpcMessage createBasicRequest(const QString &asMethod, const QJsonArray &aParams);
+ static DapRpcMessage createBasicRequest(const QString &asMethod,
+ const QJsonObject &aNamedParameters);
+
+ DapRpcMessage::Type m_type;
+ QScopedPointer<QJsonObject> m_pObject;
+
+ static int uniqueRequestCounter;
+};
+
+int DapRpcMessagePrivate::uniqueRequestCounter = 0;
+
+DapRpcMessagePrivate::DapRpcMessagePrivate()
+ : m_type(DapRpcMessage::Invalid),
+ m_pObject(nullptr)
+{
+}
+
+DapRpcMessagePrivate::DapRpcMessagePrivate(const DapRpcMessagePrivate &aDapRpcMessagePrivate)
+ : QSharedData(aDapRpcMessagePrivate),
+ m_type(aDapRpcMessagePrivate.m_type),
+ m_pObject(aDapRpcMessagePrivate.m_pObject ? new QJsonObject(*aDapRpcMessagePrivate.m_pObject) : nullptr)
+{
+}
+
+void DapRpcMessagePrivate::initializeWithObject(const QJsonObject &aMessage)
+{
+ m_pObject.reset(new QJsonObject(aMessage));
+ if (aMessage.contains(QLatin1String("id"))) {
+ if (aMessage.contains(QLatin1String("result")) ||
+ aMessage.contains(QLatin1String("error"))) {
+ if (aMessage.contains(QLatin1String("error")) &&
+ !aMessage.value(QLatin1String("error")).isNull())
+ m_type = DapRpcMessage::Error;
+ else
+ m_type = DapRpcMessage::Response;
+ } else if (aMessage.contains(QLatin1String("method"))) {
+ m_type = DapRpcMessage::Request;
+ }
+ } else {
+ if (aMessage.contains(QLatin1String("method")))
+ m_type = DapRpcMessage::Notification;
+ }
+}
+
+DapRpcMessagePrivate::~DapRpcMessagePrivate()
+{
+}
+
+DapRpcMessage::DapRpcMessage()
+ : d(new DapRpcMessagePrivate)
+{
+ d->m_pObject.reset(new QJsonObject);
+}
+
+DapRpcMessage::DapRpcMessage(const DapRpcMessage &aDapRPCMessage)
+ : d(aDapRPCMessage.d)
+{
+}
+
+DapRpcMessage::~DapRpcMessage()
+{
+}
+
+DapRpcMessage &DapRpcMessage::operator=(const DapRpcMessage &aDapRPCMessage)
+{
+ d = aDapRPCMessage.d;
+ return *this;
+}
+
+bool DapRpcMessage::operator==(const DapRpcMessage &aDapRpcMessage) const
+{
+ if (aDapRpcMessage.d == d)
+ return true;
+
+ if (aDapRpcMessage.type() == type()) {
+ if (aDapRpcMessage.type() == DapRpcMessage::Error) {
+ return (aDapRpcMessage.errorCode() == errorCode() &&
+ aDapRpcMessage.errorMessage() == errorMessage() &&
+ aDapRpcMessage.errorData() == errorData());
+ } else {
+ if (aDapRpcMessage.type() == DapRpcMessage::Notification) {
+ return (aDapRpcMessage.method() == method() &&
+ aDapRpcMessage.params() == params());
+ } else {
+ return (aDapRpcMessage.id() == id() &&
+ aDapRpcMessage.method() == method() &&
+ aDapRpcMessage.params() == params());
+ }
+ }
+ }
+
+ return false;
+}
+
+DapRpcMessage DapRpcMessage::fromJson(const QByteArray &aData)
+{
+ DapRpcMessage result;
+ QJsonParseError error;
+ QJsonDocument document = QJsonDocument::fromJson(aData, &error);
+ if (error.error != QJsonParseError::NoError) {
+ qJsonRpcDebug() << error.errorString();
+ return result;
+ }
+
+ if (!document.isObject()) {
+ qJsonRpcDebug() << "invalid message: " << aData;
+ return result;
+ }
+
+ result.d->initializeWithObject(document.object());
+ return result;
+}
+
+DapRpcMessage DapRpcMessage::fromObject(const QJsonObject &aObject)
+{
+ DapRpcMessage result;
+ result.d->initializeWithObject(aObject);
+ return result;
+}
+
+QJsonObject DapRpcMessage::toObject() const
+{
+ if (d->m_pObject)
+ return QJsonObject(*d->m_pObject);
+ return QJsonObject();
+}
+
+QByteArray DapRpcMessage::toJson() const
+{
+ if (d->m_pObject) {
+ QJsonDocument doc(*d->m_pObject);
+ return doc.toJson();
+ }
+
+ return QByteArray();
+}
+
+bool DapRpcMessage::isValid() const
+{
+ return d->m_type != DapRpcMessage::Invalid;
+}
+
+DapRpcMessage::Type DapRpcMessage::type() const
+{
+ return d->m_type;
+}
+
+DapRpcMessage DapRpcMessagePrivate::createBasicRequest(const QString &asMethod, const QJsonArray &aParams)
+{
+ DapRpcMessage request;
+ request.d->m_pObject->insert(QLatin1String("jsonrpc"), QLatin1String("2.0"));
+ request.d->m_pObject->insert(QLatin1String("method"), asMethod);
+ if (!aParams.isEmpty())
+ request.d->m_pObject->insert(QLatin1String("params"), aParams);
+ return request;
+}
+
+DapRpcMessage DapRpcMessagePrivate::createBasicRequest(const QString &asMethod,
+ const QJsonObject &aNamedParameters)
+{
+ DapRpcMessage request;
+ request.d->m_pObject->insert(QLatin1String("jsonrpc"), QLatin1String("2.0"));
+ request.d->m_pObject->insert(QLatin1String("method"), asMethod);
+ if (!aNamedParameters.isEmpty())
+ request.d->m_pObject->insert(QLatin1String("params"), aNamedParameters);
+ return request;
+}
+
+DapRpcMessage DapRpcMessage::createRequest(const QString &asMethod, const QJsonArray &aParams)
+{
+ DapRpcMessage request = DapRpcMessagePrivate::createBasicRequest(asMethod, aParams);
+ request.d->m_type = DapRpcMessage::Request;
+ DapRpcMessagePrivate::uniqueRequestCounter++;
+ request.d->m_pObject->insert(QLatin1String("id"), DapRpcMessagePrivate::uniqueRequestCounter);
+ return request;
+}
+
+DapRpcMessage DapRpcMessage::createRequest(const QString &asMethod, const QJsonValue &aParam)
+{
+ QJsonArray params;
+ params.append(aParam);
+ return createRequest(asMethod, params);
+}
+
+DapRpcMessage DapRpcMessage::createRequest(const QString &asMethod,
+ const QJsonObject &aNamedParameters)
+{
+ DapRpcMessage request =
+ DapRpcMessagePrivate::createBasicRequest(asMethod, aNamedParameters);
+ request.d->m_type = DapRpcMessage::Request;
+ DapRpcMessagePrivate::uniqueRequestCounter++;
+ request.d->m_pObject->insert(QLatin1String("id"), DapRpcMessagePrivate::uniqueRequestCounter);
+ return request;
+}
+
+DapRpcMessage DapRpcMessage::createRequest(const QString& asMethod, const QByteArray& aStream)
+{
+ DapRpcMessage request = createRequest(asMethod, QJsonValue::fromVariant(aStream));
+ return request;
+}
+
+DapRpcMessage DapRpcMessage::createNotification(const QString &asMethod, const QJsonArray &aParams)
+{
+ DapRpcMessage notification = DapRpcMessagePrivate::createBasicRequest(asMethod, aParams);
+ notification.d->m_type = DapRpcMessage::Notification;
+ return notification;
+}
+
+DapRpcMessage DapRpcMessage::createNotification(const QString &asMethod, const QJsonValue &aParam)
+{
+ QJsonArray params;
+ params.append(aParam);
+ return createNotification(asMethod, params);
+}
+
+DapRpcMessage DapRpcMessage::createNotification(const QString &asMethod,
+ const QJsonObject &aNamedParameters)
+{
+ DapRpcMessage notification =
+ DapRpcMessagePrivate::createBasicRequest(asMethod, aNamedParameters);
+ notification.d->m_type = DapRpcMessage::Notification;
+ return notification;
+}
+
+DapRpcMessage DapRpcMessage::createNotification(const QString& asMethod, const QByteArray& aStream)
+{
+ DapRpcMessage notification = createNotification(asMethod, QJsonValue::fromVariant(aStream));
+ return notification;
+}
+
+DapRpcMessage DapRpcMessage::createResponse(const QJsonValue &aResult) const
+{
+ DapRpcMessage response;
+ if (d->m_pObject->contains(QLatin1String("id"))) {
+ QJsonObject *object = response.d->m_pObject.data();
+ object->insert(QLatin1String("jsonrpc"), QLatin1String("2.0"));
+ object->insert(QLatin1String("id"), d->m_pObject->value(QLatin1String("id")));
+ object->insert(QLatin1String("result"), aResult);
+ response.d->m_type = DapRpcMessage::Response;
+ }
+
+ return response;
+}
+
+DapRpcMessage DapRpcMessage::createErrorResponse(DapErrorCode aCode,
+ const QString &asMessage,
+ const QJsonValue &aData) const
+{
+ DapRpcMessage response;
+ QJsonObject error;
+ error.insert(QLatin1String("code"), aCode);
+ if (!asMessage.isEmpty())
+ error.insert(QLatin1String("message"), asMessage);
+ if (!aData.isUndefined())
+ error.insert(QLatin1String("data"), aData);
+
+ response.d->m_type = DapRpcMessage::Error;
+ QJsonObject *object = response.d->m_pObject.data();
+ object->insert(QLatin1String("jsonrpc"), QLatin1String("2.0"));
+ if (d->m_pObject->contains(QLatin1String("id")))
+ object->insert(QLatin1String("id"), d->m_pObject->value(QLatin1String("id")));
+ else
+ object->insert(QLatin1String("id"), 0);
+ object->insert(QLatin1String("error"), error);
+ return response;
+}
+
+int DapRpcMessage::id() const
+{
+ if (d->m_type == DapRpcMessage::Notification || !d->m_pObject)
+ return -1;
+
+ const QJsonValue &value = d->m_pObject->value(QLatin1String("id"));
+ if (value.isString())
+ return value.toString().toInt();
+ return value.toInt();
+}
+
+QString DapRpcMessage::method() const
+{
+ if (d->m_type == DapRpcMessage::Response || !d->m_pObject)
+ return QString();
+
+ return d->m_pObject->value(QLatin1String("method")).toString();
+}
+
+QJsonValue DapRpcMessage::params() const
+{
+ if (d->m_type == DapRpcMessage::Response || d->m_type == DapRpcMessage::Error)
+ return QJsonValue(QJsonValue::Undefined);
+ if (!d->m_pObject)
+ return QJsonValue(QJsonValue::Undefined);
+
+ return d->m_pObject->value(QLatin1String("params"));
+}
+
+QJsonValue DapRpcMessage::toJsonValue() const
+{
+ if (d->m_type != DapRpcMessage::Response || !d->m_pObject)
+ return QJsonValue(QJsonValue::Undefined);
+
+ return d->m_pObject->value(QLatin1String("result"));
+}
+
+QByteArray DapRpcMessage::toByteArray() const
+{
+ QJsonValue value = toJsonValue();
+ return QByteArray::fromHex(value.toVariant().toByteArray());
+}
+
+int DapRpcMessage::errorCode() const
+{
+ if (d->m_type != DapRpcMessage::Error || !d->m_pObject)
+ return 0;
+
+ QJsonObject error =
+ d->m_pObject->value(QLatin1String("error")).toObject();
+ const QJsonValue &value = error.value(QLatin1String("code"));
+ if (value.isString())
+ return value.toString().toInt();
+ return value.toInt();
+}
+
+QString DapRpcMessage::errorMessage() const
+{
+ if (d->m_type != DapRpcMessage::Error || !d->m_pObject)
+ return QString();
+
+ QJsonObject error =
+ d->m_pObject->value(QLatin1String("error")).toObject();
+ return error.value(QLatin1String("message")).toString();
+}
+
+QJsonValue DapRpcMessage::errorData() const
+{
+ if (d->m_type != DapRpcMessage::Error || !d->m_pObject)
+ return QJsonValue(QJsonValue::Undefined);
+
+ QJsonObject error =
+ d->m_pObject->value(QLatin1String("error")).toObject();
+ return error.value(QLatin1String("data"));
+}
+
+static QDebug operator<<(QDebug dbg, DapRpcMessage::Type type)
+{
+ switch (type) {
+ case DapRpcMessage::Request:
+ return dbg << "DapRpcMessage::Request";
+ case DapRpcMessage::Response:
+ return dbg << "DapRpcMessage::Response";
+ case DapRpcMessage::Notification:
+ return dbg << "DapRpcMessage::Notification";
+ case DapRpcMessage::Error:
+ return dbg << "DapRpcMessage::Error";
+ default:
+ return dbg << "DapRpcMessage::Invalid";
+ }
+}
+
+QDebug operator<<(QDebug dbg, const DapRpcMessage &msg)
+{
+ dbg.nospace() << "DapRpcMessage(type=" << msg.type();
+ if (msg.type() != DapRpcMessage::Notification) {
+ dbg.nospace() << ", id=" << msg.id();
+ }
+
+ if (msg.type() == DapRpcMessage::Request ||
+ msg.type() == DapRpcMessage::Notification) {
+ dbg.nospace() << ", method=" << msg.method()
+ << ", params=" << msg.params();
+ } else if (msg.type() == DapRpcMessage::Response) {
+ dbg.nospace() << ", result=" << msg.toJsonValue();
+ } else if (msg.type() == DapRpcMessage::Error) {
+ dbg.nospace() << ", code=" << msg.errorCode()
+ << ", message=" << msg.errorMessage()
+ << ", data=" << msg.errorData();
+ }
+ dbg.nospace() << ")";
+ return dbg.space();
+}
diff --git a/dapRPCProtocol/DapRpcMessage.h b/dapRPCProtocol/DapRpcMessage.h
new file mode 100644
index 00000000..78653069
--- /dev/null
+++ b/dapRPCProtocol/DapRpcMessage.h
@@ -0,0 +1,183 @@
+#ifndef DapRPCMESSAGE_H
+#define DapRPCMESSAGE_H
+
+#include <QSharedDataPointer>
+#include <QMetaType>
+#include <QJsonDocument>
+#include <QJsonValue>
+#include <QJsonObject>
+#include <QJsonArray>
+#include <QDebug>
+
+#define qJsonRpcDebug if (qgetenv("QJSONRPC_DEBUG").isEmpty()); else qDebug
+
+/**
+ * @brief The DapErrorCode enum
+ * This enum values are used to mark code of error
+ */
+enum DapErrorCode {
+ NoError = 0, ///< No error
+ ParseError = -32700, /*!< Invalid JSON was received by the server.
+ An error occurred on the server while parsing the JSON text. */
+ InvalidRequest = -32600, ///< The JSON sent is not a valid Request object.
+ MethodNotFound = -32601, ///< The method does not exist / is not available.
+ InvalidParams = -32602, ///< Invalid method parameter(s).
+ InternalError = -32603, ///< Internal JSON-RPC error.
+ ServerErrorBase = -32000, ///< Reserved for implementation-defined server-errors.
+ UserError = -32099, ///< Anything after this is user defined
+ TimeoutError = -32100 ///< Timeout
+};
+Q_DECLARE_METATYPE(DapErrorCode)
+
+class DapRpcMessagePrivate;
+/// Class of message type by RPC protocol
+class DapRpcMessage
+{
+ friend class DapRpcMessagePrivate;
+ QSharedDataPointer<DapRpcMessagePrivate> d;
+
+public:
+ /// Standard constructor
+ DapRpcMessage();
+ /// Copy constructor
+ /// @param aDapRPCMessage Other message
+ DapRpcMessage(const DapRpcMessage &aDapRPCMessage);
+ /// Assignment operator
+ /// @param aDapRPCMessage Other message
+ /// @return RPC message
+ DapRpcMessage &operator=(const DapRpcMessage &aDapRPCMessage);
+ /// Standard destructor
+ ~DapRpcMessage();
+
+ /// Swap message
+ /// @param aDapRPCMessage Swaped message
+ inline void swap(DapRpcMessage &aDapRPCMessage) { qSwap(d, aDapRPCMessage.d); }
+
+ /**
+ * @brief The Type enum
+ * Type of message
+ */
+ enum Type {
+ Invalid, ///< Invalid
+ Request, ///< Request
+ Response, ///< Responce
+ Notification, ///< Notification
+ Error ///< Error
+ };
+
+ /// Create new request message
+ /// @param asMethod Remote method
+ /// @param aParams Params message in format JsonArray
+ /// @return aParams New RPC message
+ static DapRpcMessage createRequest(const QString &asMethod, const QJsonArray &aParams = QJsonArray());
+ /// Create new request message
+ /// @param asMethod Remote method
+ /// @param aParams Params message in format JsonValue
+ /// @return aParam New RPC message
+ static DapRpcMessage createRequest(const QString &asMethod, const QJsonValue &aParam);
+ /// Create new request message
+ /// @param asMethod Remote method
+ /// @param aNamedParameters Named params message in format JsonObject
+ /// @return New RPC message
+ static DapRpcMessage createRequest(const QString &asMethod, const QJsonObject &aNamedParameters);
+ /// Create new request message
+ /// @param asMethod Remote method
+ /// @param aStream Message stream
+ /// @return New RPC message
+ static DapRpcMessage createRequest(const QString &asMethod, const QByteArray& aStream);
+ /// Create new notification message
+ /// @param asMethod Remote method
+ /// @param aParams Params message in format JsonArray.
+ /// @return aParams New RPC message
+ static DapRpcMessage createNotification(const QString &asMethod, const QJsonArray &aParams = QJsonArray());
+ /// Create new notification message
+ /// @param asMethod Remote method
+ /// @param aParams Params message in format JsonValue
+ /// @return aParam New RPC message
+ static DapRpcMessage createNotification(const QString &asMethod, const QJsonValue &aParam);
+ /// Create new notification message
+ /// @param asMethod Remote method
+ /// @param aNamedParameters Named params message in format JsonObject
+ /// @return New RPC message
+ static DapRpcMessage createNotification(const QString &asMethod, const QJsonObject &aNamedParameters);
+ /// Create new notification message
+ /// @param asMethod Remote method
+ /// @param aStream Message stream
+ /// @return New RPC message
+ static DapRpcMessage createNotification(const QString &asMethod, const QByteArray& aStream);
+
+ /// Create new response message
+ /// @param aResult Result of operation
+ /// @return aParams Response RPC message
+ DapRpcMessage createResponse(const QJsonValue &aResult) const;
+ /// Create new error responce
+ /// @param aCode Code of error
+ /// @see DapErrorCode
+ /// @param asMessage Message
+ /// @param aData Data of message
+ /// @return Rpc message
+ DapRpcMessage createErrorResponse(DapErrorCode aCode,
+ const QString &asMessage = QString(),
+ const QJsonValue &aData = QJsonValue()) const;
+ /// Get type of message
+ /// @return Type of message
+ DapRpcMessage::Type type() const;
+ /// Validation of message
+ /// @return True if message is valid. False otherwise
+ bool isValid() const;
+ /// Get id message
+ /// @return id message
+ int id() const;
+ /// Remote method from request message
+ /// @return Remote method
+ QString method() const;
+ /// Params from request message
+ /// @return Params of message as JsonValue
+ QJsonValue params() const;
+ /// Get result of response message
+ /// @return Result of response message as JsonValue
+ QJsonValue toJsonValue() const;
+ /// Get result of response message
+ /// @return Result of response message as yteArray
+ QByteArray toByteArray() const;
+ /// Get error code. @see DapErrorCode
+ /// @return Error code
+ int errorCode() const;
+ /// Get text of error message
+ /// @return Text of error message. If message isn't error type return default string;
+ QString errorMessage() const;
+ /// Get data of error message
+ /// @return Data of error. If message isn't error type return default JsonValue
+ QJsonValue errorData() const;
+
+ /// Convert message to JsonObject
+ /// @return Message as JsonObject
+ QJsonObject toObject() const;
+ /// Static method to convert JsonObject to Rpc message
+ /// @param aObject Message as JsonObject
+ /// @return Converted message
+ static DapRpcMessage fromObject(const QJsonObject &aObject);
+
+ /// Serilize message
+ /// @return Message as byte array
+ QByteArray toJson() const;
+ /// Static method to convert serilisation message to Rpc message
+ /// @param aData Data of message
+ /// @return Converted message
+ static DapRpcMessage fromJson(const QByteArray &aData);
+
+ /// Overloaded relational operator (equal)
+ /// @param aDapRpcMessage Other message
+ /// @return True if equal and false when not
+ bool operator==(const DapRpcMessage &aDapRpcMessage) const;
+ /// Overloaded relational operator (not equal)
+ /// @param aDapRpcMessage Other message
+ /// @return True if not equal and false when yes
+ inline bool operator!=(const DapRpcMessage &aDapRpcMessage) const { return !(operator==(aDapRpcMessage)); }
+};
+
+QDebug operator<<(QDebug, const DapRpcMessage &);
+Q_DECLARE_METATYPE(DapRpcMessage)
+Q_DECLARE_SHARED(DapRpcMessage)
+
+#endif // DapRPCMESSAGE_H
diff --git a/dapRPCProtocol/DapRpcService.cpp b/dapRPCProtocol/DapRpcService.cpp
new file mode 100644
index 00000000..05826c00
--- /dev/null
+++ b/dapRPCProtocol/DapRpcService.cpp
@@ -0,0 +1,351 @@
+#include "DapRpcService.h"
+#include "DapRpcSocket.h"
+
+ParameterInfo::ParameterInfo(const QString &asName, int aType, bool aOut)
+ : type(aType),
+ jsType(DapRpcService::convertVariantTypeToJSType(aType)),
+ name(asName),
+ out(aOut)
+{
+}
+
+MethodInfo::MethodInfo()
+ : returnType(QMetaType::Void),
+ valid(false),
+ hasOut(false)
+{
+}
+
+MethodInfo::MethodInfo(const QMetaMethod &aMethod)
+ : returnType(QMetaType::Void),
+ valid(true),
+ hasOut(false)
+{
+ returnType = aMethod.returnType();
+ if (returnType == QMetaType::UnknownType) {
+ qJsonRpcDebug() << "DapRpcService: can't bind method's return type"
+ << QString(aMethod.name());
+ valid = false;
+ return;
+ }
+
+ parameters.reserve(aMethod.parameterCount());
+
+ const QList<QByteArray> &types = aMethod.parameterTypes();
+ const QList<QByteArray> &names = aMethod.parameterNames();
+ for (int i = 0; i < types.size(); ++i) {
+ QByteArray parameterType = types.at(i);
+ const QByteArray ¶meterName = names.at(i);
+ bool out = parameterType.endsWith('&');
+
+ if (out) {
+ hasOut = true;
+ parameterType.resize(parameterType.size() - 1);
+ }
+
+ int type = QMetaType::type(parameterType);
+ if (type == 0) {
+ qJsonRpcDebug() << "DapRpcService: can't bind method's parameter"
+ << QString(parameterType);
+ valid = false;
+ break;
+ }
+
+ parameters.append(ParameterInfo(parameterName, type, out));
+ }
+}
+
+void DapRpcService::setCurrentRequest(const DapRpcServiceRequest &aCurrentRequest)
+{
+ m_currentRequest = aCurrentRequest;
+}
+
+QString DapRpcService::getName() const
+{
+ return m_sName;
+}
+
+DapRpcService::DapRpcService(const QString &asName, QObject *apParent)
+ : QObject(apParent), m_sName(asName)
+{
+}
+
+DapRpcService::~DapRpcService()
+{
+}
+
+DapRpcServiceRequest DapRpcService::currentRequest() const
+{
+ return m_currentRequest;
+}
+
+void DapRpcService::beginDelayedResponse()
+{
+ m_delayedResponse = true;
+}
+
+int DapRpcService::convertVariantTypeToJSType(int aType)
+{
+ switch (aType) {
+ case QMetaType::Int:
+ case QMetaType::UInt:
+ case QMetaType::Double:
+ case QMetaType::Long:
+ case QMetaType::LongLong:
+ case QMetaType::Short:
+ case QMetaType::Char:
+ case QMetaType::ULong:
+ case QMetaType::ULongLong:
+ case QMetaType::UShort:
+ case QMetaType::UChar:
+ case QMetaType::Float:
+ return QJsonValue::Double; // all numeric types in js are doubles
+ case QMetaType::QVariantList:
+ case QMetaType::QStringList:
+ return QJsonValue::Array;
+ case QMetaType::QVariantMap:
+ return QJsonValue::Object;
+ case QMetaType::QByteArray:
+ case QMetaType::QString:
+ return QJsonValue::String;
+ case QMetaType::Bool:
+ return QJsonValue::Bool;
+ default: break;
+ }
+
+ return QJsonValue::Undefined;
+}
+
+int DapRpcService::qjsonRpcMessageType = qRegisterMetaType<DapRpcMessage>("DapRpcMessage");
+void DapRpcService::cacheInvokableInfo()
+{
+ const QMetaObject *obj = metaObject();
+ int startIdx = staticMetaObject.methodCount(); // skip QObject slots
+ for (int idx = startIdx; idx < obj->methodCount(); ++idx) {
+ const QMetaMethod method = obj->method(idx);
+ if ((method.methodType() == QMetaMethod::Slot &&
+ method.access() == QMetaMethod::Public) ||
+ method.methodType() == QMetaMethod::Signal) {
+
+ QByteArray signature = method.methodSignature();
+ QByteArray methodName = method.name();
+
+ MethodInfo info(method);
+ if (!info.valid)
+ continue;
+
+ if (signature.contains("QVariant"))
+ m_invokableMethodHash[methodName].append(idx);
+ else
+ m_invokableMethodHash[methodName].prepend(idx);
+ m_methodInfoHash[idx] = info;
+ }
+ }
+}
+
+static bool jsParameterCompare(const QJsonArray ¶meters,
+ const MethodInfo &info)
+{
+ int j = 0;
+ for (int i = 0; i < info.parameters.size() && j < parameters.size(); ++i) {
+ int jsType = info.parameters.at(i).jsType;
+ if (jsType != QJsonValue::Undefined && jsType != parameters.at(j).type()) {
+ if (!info.parameters.at(i).out)
+ return false;
+ } else {
+ ++j;
+ }
+ }
+
+ return (j == parameters.size());
+}
+
+static bool jsParameterCompare(const QJsonObject ¶meters,
+ const MethodInfo &info)
+{
+ for (int i = 0; i < info.parameters.size(); ++i) {
+ int jsType = info.parameters.at(i).jsType;
+ QJsonValue value = parameters.value(info.parameters.at(i).name);
+ if (value == QJsonValue::Undefined) {
+ if (!info.parameters.at(i).out)
+ return false;
+ } else if (jsType == QJsonValue::Undefined) {
+ continue;
+ } else if (jsType != value.type()) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+static inline QVariant convertArgument(const QJsonValue &argument,
+ const ParameterInfo &info)
+{
+ if (argument.isUndefined())
+ return QVariant(info.type, Q_NULLPTR);
+
+ if (info.type == QMetaType::QJsonValue || info.type == QMetaType::QVariant ||
+ info.type >= QMetaType::User) {
+
+ if (info.type == QMetaType::QVariant)
+ return argument.toVariant();
+
+ QVariant result(argument);
+ if (info.type >= QMetaType::User && result.canConvert(info.type))
+ result.convert(info.type);
+ return result;
+ }
+
+ QVariant result = argument.toVariant();
+ if (result.userType() == info.type || info.type == QMetaType::QVariant) {
+ return result;
+ } else if (result.canConvert(info.type)) {
+ result.convert(info.type);
+ return result;
+ } else if (info.type < QMetaType::User) {
+ // already tried for >= user, this is the last resort
+ QVariant result(argument);
+ if (result.canConvert(info.type)) {
+ result.convert(info.type);
+ return result;
+ }
+ }
+
+ return QVariant();
+}
+
+QJsonValue DapRpcService::convertReturnValue(QVariant &aReturnValue)
+{
+ if (static_cast<int>(aReturnValue.type()) == qMetaTypeId<QJsonObject>())
+ return QJsonValue(aReturnValue.toJsonObject());
+ else if (static_cast<int>(aReturnValue.type()) == qMetaTypeId<QJsonArray>())
+ return QJsonValue(aReturnValue.toJsonArray());
+
+ switch (static_cast<QMetaType::Type>(aReturnValue.type())) {
+ case QMetaType::Bool:
+ case QMetaType::Int:
+ case QMetaType::Double:
+ case QMetaType::LongLong:
+ case QMetaType::ULongLong:
+ case QMetaType::UInt:
+ case QMetaType::QString:
+ case QMetaType::QStringList:
+ case QMetaType::QVariantList:
+ case QMetaType::QVariantMap:
+ return QJsonValue::fromVariant(aReturnValue);
+ case QMetaType::QByteArray:
+ {
+ QJsonValue var = QJsonValue::fromVariant(aReturnValue);
+ return var;
+ }
+ default:
+ // if a conversion operator was registered it will be used
+ if (aReturnValue.convert(QMetaType::QJsonValue))
+ return aReturnValue.toJsonValue();
+ else
+ return QJsonValue();
+ }
+}
+
+static inline QByteArray methodName(const DapRpcMessage &request)
+{
+ const QString &methodPath(request.method());
+ return methodPath.midRef(methodPath.lastIndexOf('.') + 1).toLatin1();
+}
+
+DapRpcMessage DapRpcService::dispatch(const DapRpcMessage &aRequest)
+{
+ if (aRequest.type() != DapRpcMessage::Request &&
+ aRequest.type() != DapRpcMessage::Notification) {
+ return aRequest.createErrorResponse(DapErrorCode::InvalidRequest, "invalid request");
+ }
+
+ const QByteArray &method(methodName(aRequest));
+ qDebug() << method;
+ if (!m_invokableMethodHash.contains(method)) {
+ return aRequest.createErrorResponse(DapErrorCode::MethodNotFound, "invalid method called");
+ }
+
+ int idx = -1;
+ QVariantList arguments;
+ const QList<int> &indexes = m_invokableMethodHash.value(method);
+ const QJsonValue ¶ms = aRequest.params();
+ QVarLengthArray<void *, 10> parameters;
+ QVariant returnValue;
+ QMetaType::Type returnType = QMetaType::Void;
+
+ bool usingNamedParameters = params.isObject();
+ foreach (int methodIndex, indexes) {
+ MethodInfo &info = m_methodInfoHash[methodIndex];
+ bool methodMatch = usingNamedParameters ?
+ jsParameterCompare(params.toObject(), info) :
+ jsParameterCompare(params.toArray(), info);
+
+ if (methodMatch) {
+ idx = methodIndex;
+ arguments.reserve(info.parameters.size());
+ returnType = static_cast<QMetaType::Type>(info.returnType);
+ returnValue = (returnType == QMetaType::Void) ?
+ QVariant() : QVariant(returnType, Q_NULLPTR);
+ if (returnType == QMetaType::QVariant)
+ parameters.append(&returnValue);
+ else
+ parameters.append(returnValue.data());
+
+ for (int i = 0; i < info.parameters.size(); ++i) {
+ const ParameterInfo ¶meterInfo = info.parameters.at(i);
+ QJsonValue incomingArgument = usingNamedParameters ?
+ params.toObject().value(parameterInfo.name) :
+ params.toArray().at(i);
+
+ QVariant argument = convertArgument(incomingArgument, parameterInfo);
+ if (!argument.isValid()) {
+ QString message = incomingArgument.isUndefined() ?
+ QString("failed to construct default object for '%1'").arg(parameterInfo.name) :
+ QString("failed to convert from JSON for '%1'").arg(parameterInfo.name);
+ return aRequest.createErrorResponse(DapErrorCode::InvalidParams, message);
+ }
+
+ arguments.push_back(argument);
+ if (parameterInfo.type == QMetaType::QVariant)
+ parameters.append(static_cast<void *>(&arguments.last()));
+ else
+ parameters.append(const_cast<void *>(arguments.last().constData()));
+ }
+ break;
+ }
+ }
+
+ if (idx == -1) {
+ return aRequest.createErrorResponse(DapErrorCode::InvalidParams, "invalid parameters");
+ }
+
+ MethodInfo &info = m_methodInfoHash[idx];
+
+ bool success =
+ const_cast<DapRpcService*>(this)->qt_metacall(QMetaObject::InvokeMetaMethod, idx, parameters.data()) < 0;
+ if (!success) {
+ QString message = QString("dispatch for method '%1' failed").arg(method.constData());
+ return aRequest.createErrorResponse(DapErrorCode::InvalidRequest, message);
+ }
+
+ if (m_delayedResponse) {
+ m_delayedResponse = false;
+ return DapRpcMessage();
+ }
+
+ if (info.hasOut) {
+ QJsonArray ret;
+ if (info.returnType != QMetaType::Void)
+ ret.append(convertReturnValue(returnValue));
+ for (int i = 0; i < info.parameters.size(); ++i)
+ if (info.parameters.at(i).out)
+ ret.append(convertReturnValue(arguments[i]));
+ if (ret.size() > 1)
+ return aRequest.createResponse(ret);
+ return aRequest.createResponse(ret.first());
+ }
+
+ return aRequest.createResponse(convertReturnValue(returnValue));
+}
diff --git a/dapRPCProtocol/DapRpcService.h b/dapRPCProtocol/DapRpcService.h
new file mode 100644
index 00000000..6e348b96
--- /dev/null
+++ b/dapRPCProtocol/DapRpcService.h
@@ -0,0 +1,75 @@
+#ifndef DapRPCSERVICE_H
+#define DapRPCSERVICE_H
+
+#include <QObject>
+#include <QVariant>
+#include <QPointer>
+#include <QVarLengthArray>
+#include <QMetaMethod>
+#include <QEventLoop>
+#include <QDebug>
+
+
+#include "DapRpcMessage.h"
+#include "DapRpcServiceRequest.h"
+
+struct ParameterInfo
+{
+ ParameterInfo(const QString &asName = QString(), int aType = 0, bool aOut = false);
+
+ int type;
+ int jsType;
+ QString name;
+ bool out;
+};
+
+struct MethodInfo
+{
+ MethodInfo();
+ MethodInfo(const QMetaMethod &aMethod);
+
+ QVarLengthArray<ParameterInfo> parameters;
+ int returnType;
+ bool valid;
+ bool hasOut;
+};
+
+class DapRpcService : public QObject
+{
+ Q_OBJECT
+ Q_DISABLE_COPY(DapRpcService)
+
+ QHash<int, MethodInfo > m_methodInfoHash;
+ QHash<QByteArray, QList<int> > m_invokableMethodHash;
+ DapRpcServiceRequest m_currentRequest;
+ bool m_delayedResponse {false};
+ QString m_sName;
+
+protected:
+ DapRpcServiceRequest currentRequest() const;
+ void beginDelayedResponse();
+
+public:
+ explicit DapRpcService(const QString &asName, QObject *apParent = nullptr);
+ ~DapRpcService();
+
+ void cacheInvokableInfo();
+ static int qjsonRpcMessageType;
+ static int convertVariantTypeToJSType(int aType);
+ static QJsonValue convertReturnValue(QVariant &aReturnValue);
+
+ void setCurrentRequest(const DapRpcServiceRequest &aCurrentRequest);
+
+ QString getName() const;
+
+signals:
+ void result(const DapRpcMessage &aDapRpcMessage);
+ void notifyConnectedClients(const DapRpcMessage &aDapRpcMessage);
+ void notifyConnectedClients(const QString &asMethod, const QJsonArray &aParams = QJsonArray());
+
+public slots:
+ DapRpcMessage dispatch(const DapRpcMessage &aRequest);
+};
+
+#endif // DapRPCSERVICE_H
+
diff --git a/dapRPCProtocol/DapRpcServiceProvider.cpp b/dapRPCProtocol/DapRpcServiceProvider.cpp
new file mode 100644
index 00000000..7032c37d
--- /dev/null
+++ b/dapRPCProtocol/DapRpcServiceProvider.cpp
@@ -0,0 +1,107 @@
+#include "DapRpcServiceProvider.h"
+#include "DapRpcSocket.h"
+
+DapRpcServiceProvider::DapRpcServiceProvider()
+{
+}
+
+DapRpcServiceProvider::~DapRpcServiceProvider()
+{
+}
+
+QByteArray DapRpcServiceProvider::getServiceName(DapRpcService *apService)
+{
+ const QMetaObject *mo = apService->metaObject();
+ for (int i = 0; i < mo->classInfoCount(); i++)
+ {
+ const QMetaClassInfo mci = mo->classInfo(i);
+ if (mci.name() == QLatin1String("serviceName"))
+ return mci.value();
+ }
+
+ return QByteArray(mo->className()).toLower();
+}
+
+DapRpcService * DapRpcServiceProvider::addService(DapRpcService *apService)
+{
+ QByteArray serviceName = apService->getName().toUtf8();
+ if (serviceName.isEmpty()) {
+ qJsonRpcDebug() << "service added without serviceName classinfo, aborting";
+ return nullptr;
+ }
+
+ if (m_services.contains(serviceName)) {
+ qJsonRpcDebug() << "service with name " << serviceName << " already exist";
+ return nullptr;
+ }
+
+ apService->cacheInvokableInfo();
+ m_services.insert(serviceName, apService);
+ if (!apService->parent())
+ m_cleanupHandler.add(apService);
+ return apService;
+}
+
+bool DapRpcServiceProvider::removeService(DapRpcService *apService)
+{
+ QByteArray serviceName = getServiceName(apService);
+ if (!m_services.contains(serviceName)) {
+ qJsonRpcDebug() << "can not find service with name " << serviceName;
+ return false;
+ }
+
+ m_cleanupHandler.remove(m_services.value(serviceName));
+ m_services.remove(serviceName);
+ return true;
+}
+
+DapRpcService* DapRpcServiceProvider::findService(const QString &asServiceName)
+{
+ if (!m_services.contains(QByteArray::fromStdString(asServiceName.toStdString())))
+ {
+ qJsonRpcDebug() << "can not find service with name " << asServiceName;
+ return nullptr;
+ }
+ return m_services.value(QByteArray::fromStdString(asServiceName.toStdString()));
+}
+
+void DapRpcServiceProvider::processMessage(DapRpcSocket *apSocket, const DapRpcMessage &aMessage)
+{
+ switch (aMessage.type()) {
+ case DapRpcMessage::Request:
+ case DapRpcMessage::Notification: {
+ QByteArray serviceName = aMessage.method().section(".", 0, -2).toLatin1();
+ bool b = m_services.contains(serviceName);
+ if (serviceName.isEmpty() || !m_services.contains(serviceName))
+ {
+ if (aMessage.type() == DapRpcMessage::Request)
+ {
+ DapRpcMessage error =
+ aMessage.createErrorResponse(DapErrorCode::MethodNotFound,
+ QString("service '%1' not found").arg(serviceName.constData()));
+ apSocket->notify(error);
+ }
+ } else {
+ DapRpcService *service = m_services.value(serviceName);
+ service->setCurrentRequest(DapRpcServiceRequest(aMessage, apSocket));
+ if (aMessage.type() == DapRpcMessage::Request)
+ QObject::connect(service, SIGNAL(result(DapRpcMessage)),
+ apSocket, SLOT(notify(DapRpcMessage)), Qt::UniqueConnection);
+ DapRpcMessage response = service->dispatch(aMessage);
+ if (response.isValid())
+ apSocket->notify(response);
+ }
+ }
+ break;
+
+ case DapRpcMessage::Response:
+ break;
+
+ default: {
+ DapRpcMessage error =
+ aMessage.createErrorResponse(DapErrorCode::InvalidRequest, QString("invalid request"));
+ apSocket->notify(error);
+ break;
+ }
+ }
+}
diff --git a/dapRPCProtocol/DapRpcServiceProvider.h b/dapRPCProtocol/DapRpcServiceProvider.h
new file mode 100644
index 00000000..6377d1bf
--- /dev/null
+++ b/dapRPCProtocol/DapRpcServiceProvider.h
@@ -0,0 +1,51 @@
+#ifndef DapRPCSERVICEPROVIDER_H
+#define DapRPCSERVICEPROVIDER_H
+
+#include <QScopedPointer>
+#include <QObjectCleanupHandler>
+#include <QHash>
+#include <QMetaObject>
+#include <QMetaClassInfo>
+#include <QDebug>
+
+#include "DapRpcService.h"
+
+/**
+ * @brief The DapRpcServiceProvider class
+ * Class provides to add/remove services and store them.
+ */
+class DapRpcServiceProvider
+{
+ /// Store pointers to service by the name
+ QHash<QByteArray, DapRpcService*> m_services;
+ /// Handle service to cleanup
+ QObjectCleanupHandler m_cleanupHandler;
+
+protected:
+ /// Standard constructor
+ DapRpcServiceProvider();
+ /// Process message to send by socket interface
+ /// @param apSocket Remote socket
+ /// aMessage Rpc message
+ void processMessage(DapRpcSocket *apSocket, const DapRpcMessage &aMessage);
+
+public:
+ /// Virtual destructor
+ virtual ~DapRpcServiceProvider();
+ /// Add new service
+ /// @param apService New service
+ /// @return True if service add successfullym false if not
+ virtual DapRpcService *addService(DapRpcService *apService);
+ /// Remove existing service
+ /// @param apService Service to remove
+ /// @return If service alreade removing or not existing return false, else return true
+ virtual bool removeService(DapRpcService *apService);
+
+ virtual DapRpcService *findService(const QString& asServiceName);
+ /// Get service name
+ /// @param apService Service
+ /// @return Serilization name of service
+ QByteArray getServiceName(DapRpcService *apService);
+};
+
+#endif // DapRPCSERVICEPROVIDER_H
diff --git a/dapRPCProtocol/DapRpcServiceReply.cpp b/dapRPCProtocol/DapRpcServiceReply.cpp
new file mode 100644
index 00000000..ba26f389
--- /dev/null
+++ b/dapRPCProtocol/DapRpcServiceReply.cpp
@@ -0,0 +1,31 @@
+#include "DapRpcServiceReply.h"
+
+DapRpcServiceReply::DapRpcServiceReply(QObject *apParent)
+ : QObject(apParent)
+{
+}
+
+DapRpcServiceReply::~DapRpcServiceReply()
+{
+
+}
+
+void DapRpcServiceReply::setRequest(const DapRpcMessage &aRequest)
+{
+ m_request = aRequest;
+}
+
+void DapRpcServiceReply::setResponse(const DapRpcMessage &aResponse)
+{
+ m_response = aResponse;
+}
+
+DapRpcMessage DapRpcServiceReply::request() const
+{
+ return m_request;
+}
+
+DapRpcMessage DapRpcServiceReply::response() const
+{
+ return m_response;
+}
diff --git a/dapRPCProtocol/DapRpcServiceReply.h b/dapRPCProtocol/DapRpcServiceReply.h
new file mode 100644
index 00000000..c608ab95
--- /dev/null
+++ b/dapRPCProtocol/DapRpcServiceReply.h
@@ -0,0 +1,48 @@
+#ifndef DapRPCSERVICEREPLY_H
+#define DapRPCSERVICEREPLY_H
+
+#include <QObject>
+#include <QNetworkReply>
+
+#include "DapRpcMessage.h"
+
+/**
+ * @brief The DapRpcServiceReply class
+ * Class provides service reply from sender.
+ * Class has methods to operate with response and request
+ */
+class DapRpcServiceReply : public QObject
+{
+ Q_OBJECT
+ Q_DISABLE_COPY(DapRpcServiceReply)
+ /// Request message
+ DapRpcMessage m_request;
+ /// Response message
+ DapRpcMessage m_response;
+
+public:
+ /// Standard constructor
+ explicit DapRpcServiceReply(QObject *apParent = nullptr);
+ /// Virtual destructor
+ virtual ~DapRpcServiceReply();
+
+ /// Get request message
+ /// @return Request message
+ DapRpcMessage request() const;
+ /// Get response message
+ /// @return Response message
+ DapRpcMessage response() const;
+
+ /// Set request message
+ /// @param aRequest New request message
+ void setRequest(const DapRpcMessage &aRequest);
+ /// Set response message
+ /// @param aResponse Responce message
+ void setResponse(const DapRpcMessage &aResponse);
+
+signals:
+ /// The signal is emitted when reply finished
+ void finished();
+};
+
+#endif // DapRPCSERVICEREPLY_H
diff --git a/dapRPCProtocol/DapRpcServiceRequest.cpp b/dapRPCProtocol/DapRpcServiceRequest.cpp
new file mode 100644
index 00000000..3a00a07b
--- /dev/null
+++ b/dapRPCProtocol/DapRpcServiceRequest.cpp
@@ -0,0 +1,69 @@
+#include "DapRpcSocket.h"
+#include "DapRpcServiceRequest.h"
+
+
+DapRpcServiceRequest::DapRpcServiceRequest()
+{
+}
+
+DapRpcServiceRequest::~DapRpcServiceRequest()
+{
+}
+
+DapRpcServiceRequest::DapRpcServiceRequest(const DapRpcServiceRequest &aDapRpcServiceRequest)
+{
+ m_request = aDapRpcServiceRequest.m_request;
+ m_socket = aDapRpcServiceRequest.m_socket;
+}
+
+DapRpcServiceRequest::DapRpcServiceRequest(const DapRpcMessage &aRequest,
+ DapRpcSocket *apSocket)
+{
+ m_request = aRequest;
+ m_socket = apSocket;
+}
+
+DapRpcServiceRequest &DapRpcServiceRequest::operator=(const DapRpcServiceRequest &other)
+{
+ m_request = other.m_request;
+ m_socket = other.m_socket;
+ return *this;
+}
+
+bool DapRpcServiceRequest::isValid() const
+{
+ return (m_request.isValid() && !m_socket.isNull());
+}
+
+DapRpcMessage DapRpcServiceRequest::request() const
+{
+ return m_request;
+}
+
+DapRpcSocket *DapRpcServiceRequest::socket() const
+{
+ return m_socket;
+}
+
+bool DapRpcServiceRequest::respond(QVariant aReturnValue)
+{
+ if (!m_socket) {
+ qJsonRpcDebug() << "socket was closed";
+ return false;
+ }
+
+ DapRpcMessage response =
+ m_request.createResponse(DapRpcService::convertReturnValue(aReturnValue));
+ return respond(response);
+}
+
+bool DapRpcServiceRequest::respond(const DapRpcMessage &aResponse)
+{
+ if (!m_socket) {
+ qJsonRpcDebug() << "socket was closed";
+ return false;
+ }
+
+ QMetaObject::invokeMethod(m_socket, "notify", Q_ARG(DapRpcMessage, aResponse));
+ return true;
+}
diff --git a/dapRPCProtocol/DapRpcServiceRequest.h b/dapRPCProtocol/DapRpcServiceRequest.h
new file mode 100644
index 00000000..0949ff6a
--- /dev/null
+++ b/dapRPCProtocol/DapRpcServiceRequest.h
@@ -0,0 +1,60 @@
+#ifndef DapRPCSERVICEREQUEST_H
+#define DapRPCSERVICEREQUEST_H
+
+#include <QPointer>
+#include <QMetaObject>
+#include <QDebug>
+
+#include "DapRpcMessage.h"
+
+class DapRpcSocket;
+/**
+ * @brief The DapRpcServiceRequest class
+ * Class provides to operate with request message by socket interface
+ * @see DapRpcSocket
+ */
+class DapRpcServiceRequest
+{
+ /// Request message
+ DapRpcMessage m_request;
+ /// RPC socket
+ QPointer<DapRpcSocket> m_socket;
+
+public:
+ /// Standard constructor
+ DapRpcServiceRequest();
+ /// Copy constructor
+ DapRpcServiceRequest(const DapRpcServiceRequest &aDapRpcServiceRequest);
+ /// Overloaded constructor
+ /// @param aRequest Request message
+ /// @param apSocket Pointer to RPC socket
+ DapRpcServiceRequest(const DapRpcMessage &aRequest, DapRpcSocket *apSocket);
+ /// Overloaded assignment operator
+ /// @param aDapRpcServiceRequest Other DapRpcServiceRequest object
+ /// @return Reference to this object
+ DapRpcServiceRequest &operator=(const DapRpcServiceRequest &aDapRpcServiceRequest);
+ /// Standard destructor
+ ~DapRpcServiceRequest();
+
+ /// Validation of request message
+ /// @return If request message is valid or socket is not null return true.
+ /// Otherwise return false
+ bool isValid() const;
+ /// Get request message
+ /// @return Request message
+ DapRpcMessage request() const;
+ /// Get current socket
+ /// @return Socket
+ DapRpcSocket *socket() const;
+
+ /// Create response to following respont by socket
+ /// @param aReturnValue Return value from service
+ /// @return False if socket is closed
+ bool respond(QVariant aReturnValue);
+ /// Send response to socket
+ /// @param aResponse Response message
+ /// @return False if socket is closed
+ bool respond(const DapRpcMessage &aResponse);
+};
+
+#endif // DapRPCSERVICEREQUEST_H
diff --git a/dapRPCProtocol/DapRpcSocket.cpp b/dapRPCProtocol/DapRpcSocket.cpp
new file mode 100644
index 00000000..c3de0fca
--- /dev/null
+++ b/dapRPCProtocol/DapRpcSocket.cpp
@@ -0,0 +1,266 @@
+#include "DapRpcSocket.h"
+#include "DapRpcService.h"
+
+DapRpcSocket::DapRpcSocket(QObject *apParent)
+ : QObject(apParent)
+{
+
+}
+
+DapRpcSocket::DapRpcSocket(QIODevice *apDevice, QObject *apParent)
+ : QObject(apParent)
+{
+ m_pDevice = apDevice;
+ connect(m_pDevice, SIGNAL(readyRead()), this, SLOT(processIncomingData()));
+}
+
+DapRpcSocket::~DapRpcSocket()
+{
+}
+
+int DapRpcSocket::findJsonDocumentEnd(const QByteArray &aJsonData)
+{
+ const char* pos = aJsonData.constData();
+ const char* end = pos + aJsonData.length();
+
+ char blockStart = 0;
+ char blockEnd = 0;
+ int index = 0;
+
+ while (true) {
+ if (pos == end) {
+ return -1;
+ } else if (*pos == '{') {
+ blockStart = '{';
+ blockEnd = '}';
+ break;
+ } else if(*pos == '[') {
+ blockStart = '[';
+ blockEnd = ']';
+ break;
+ }
+
+ pos++;
+ index++;
+ }
+
+ pos++;
+ index++;
+ int depth = 1;
+ bool inString = false;
+ while (depth > 0 && pos <= end) {
+ if (*pos == '\\') {
+ pos += 2;
+ index += 2;
+ continue;
+ } else if (*pos == '"') {
+ inString = !inString;
+ } else if (!inString) {
+ if (*pos == blockStart)
+ depth++;
+ else if (*pos == blockEnd)
+ depth--;
+ }
+
+ pos++;
+ index++;
+ }
+
+ return depth == 0 ? index-1 : -1;
+}
+
+void DapRpcSocket::writeData(const DapRpcMessage &asMessage)
+{
+ QJsonDocument doc = QJsonDocument(asMessage.toObject());
+ QByteArray data = doc.toJson(QJsonDocument::Compact);
+
+ m_pDevice.data()->write(data);
+ qJsonRpcDebug() << "sending: " << data;
+}
+
+void DapRpcSocket::setDefaultRequestTimeout(int aiMsecs)
+{
+ if (aiMsecs < 0) {
+ qJsonRpcDebug() << "Cannot set a negative request timeout msecs value";
+ return;
+ }
+
+ m_defaultRequestTimeout = aiMsecs;
+}
+
+int DapRpcSocket::getDefaultRequestTimeout() const
+{
+ return m_defaultRequestTimeout;
+}
+
+bool DapRpcSocket::isValid() const
+{
+ return m_pDevice && m_pDevice.data()->isOpen();
+}
+
+DapRpcMessage DapRpcSocket::sendMessageBlocking(const DapRpcMessage &asMessage, int aMsecs)
+{
+ DapRpcServiceReply *reply = sendMessage(asMessage);
+ QScopedPointer<DapRpcServiceReply> replyPtr(reply);
+
+ QEventLoop responseLoop;
+ connect(reply, SIGNAL(finished()), &responseLoop, SLOT(quit()));
+ QTimer::singleShot(aMsecs, &responseLoop, SLOT(quit()));
+ responseLoop.exec();
+
+ if (!reply->response().isValid()) {
+ m_replies.remove(asMessage.id());
+ return asMessage.createErrorResponse(DapErrorCode::TimeoutError, "request timed out");
+ }
+
+ return reply->response();
+}
+
+DapRpcServiceReply *DapRpcSocket::sendMessage(const DapRpcMessage &asMessage)
+{
+ if (!m_pDevice) {
+ qJsonRpcDebug() << "trying to send message without device";
+ return nullptr;
+ }
+
+ notify(asMessage);
+ QPointer<DapRpcServiceReply> reply(new DapRpcServiceReply);
+ reply->setRequest(asMessage);
+ m_replies.insert(asMessage.id(), reply);
+ return reply;
+}
+
+void DapRpcSocket::notify(const DapRpcMessage &asMessage)
+{
+ if (!m_pDevice) {
+ qJsonRpcDebug() << "trying to send message without device";
+ return;
+ }
+
+ DapRpcService *service = qobject_cast<DapRpcService*>(sender());
+ if (service)
+ disconnect(service, SIGNAL(result(DapRpcMessage)), this, SLOT(notify(DapRpcMessage)));
+
+ writeData(asMessage);
+}
+
+DapRpcMessage DapRpcSocket::invokeRemoteMethodBlocking(const QString &asMethod, int aMsecs, const QVariant ¶m1,
+ const QVariant ¶m2, const QVariant ¶m3,
+ const QVariant ¶m4, const QVariant ¶m5,
+ const QVariant ¶m6, const QVariant ¶m7,
+ const QVariant ¶m8, const QVariant ¶m9,
+ const QVariant ¶m10)
+{
+ QVariantList params;
+ if (param1.isValid()) params.append(param1);
+ if (param2.isValid()) params.append(param2);
+ if (param3.isValid()) params.append(param3);
+ if (param4.isValid()) params.append(param4);
+ if (param5.isValid()) params.append(param5);
+ if (param6.isValid()) params.append(param6);
+ if (param7.isValid()) params.append(param7);
+ if (param8.isValid()) params.append(param8);
+ if (param9.isValid()) params.append(param9);
+ if (param10.isValid()) params.append(param10);
+
+ DapRpcMessage request =
+ DapRpcMessage::createRequest(asMethod, QJsonArray::fromVariantList(params));
+ return sendMessageBlocking(request, aMsecs);
+}
+
+DapRpcMessage DapRpcSocket::invokeRemoteMethodBlocking(const QString &asMethod, const QVariant ¶m1,
+ const QVariant ¶m2, const QVariant ¶m3,
+ const QVariant ¶m4, const QVariant ¶m5,
+ const QVariant ¶m6, const QVariant ¶m7,
+ const QVariant ¶m8, const QVariant ¶m9,
+ const QVariant ¶m10)
+{
+ return invokeRemoteMethodBlocking(asMethod, m_defaultRequestTimeout, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
+}
+
+DapRpcServiceReply *DapRpcSocket::invokeRemoteMethod(const QString &asMethod, const QVariant ¶m1,
+ const QVariant ¶m2, const QVariant ¶m3,
+ const QVariant ¶m4, const QVariant ¶m5,
+ const QVariant ¶m6, const QVariant ¶m7,
+ const QVariant ¶m8, const QVariant ¶m9,
+ const QVariant ¶m10)
+{
+ QVariantList params;
+ if (param1.isValid()) params.append(param1);
+ if (param2.isValid()) params.append(param2);
+ if (param3.isValid()) params.append(param3);
+ if (param4.isValid()) params.append(param4);
+ if (param5.isValid()) params.append(param5);
+ if (param6.isValid()) params.append(param6);
+ if (param7.isValid()) params.append(param7);
+ if (param8.isValid()) params.append(param8);
+ if (param9.isValid()) params.append(param9);
+ if (param10.isValid()) params.append(param10);
+
+ DapRpcMessage request =
+ DapRpcMessage::createRequest(asMethod, QJsonArray::fromVariantList(params));
+ return invokeRemoteMethod(request);
+}
+
+DapRpcServiceReply *DapRpcSocket::invokeRemoteMethod(const DapRpcMessage &message)
+{
+ return sendMessage(message);
+}
+
+void DapRpcSocket::processIncomingData()
+{
+ if (!m_pDevice) {
+ qJsonRpcDebug() << "called without device";
+ return;
+ }
+
+ m_aBuffer.append(m_pDevice.data()->readAll());
+ while (!m_aBuffer.isEmpty()) {
+ int dataSize = findJsonDocumentEnd(m_aBuffer);
+ if (dataSize == -1) {
+ return;
+ }
+
+ QJsonParseError error;
+ QJsonDocument document = QJsonDocument::fromJson(m_aBuffer.mid(0, dataSize + 1), &error);
+ if (document.isEmpty()) {
+ if (error.error != QJsonParseError::NoError) {
+ qJsonRpcDebug() << error.errorString();
+ }
+
+ break;
+ }
+
+ m_aBuffer = m_aBuffer.mid(dataSize + 1);
+ if (document.isArray()) {
+ qJsonRpcDebug() << "bulk support is current disabled";
+ } else if (document.isObject()){
+ qJsonRpcDebug() << "received: " << document.toJson(QJsonDocument::Compact);
+ DapRpcMessage message = DapRpcMessage::fromObject(document.object());
+ Q_EMIT messageReceived(message);
+ if (message.type() == DapRpcMessage::Response ||
+ message.type() == DapRpcMessage::Error) {
+ if (m_replies.contains(message.id())) {
+ QPointer<DapRpcServiceReply> reply = m_replies.take(message.id());
+ if (!reply.isNull()) {
+ reply->setResponse(message);
+ reply->finished();
+ }
+ }
+ } else {
+ processRequestMessage(message);
+ }
+ }
+ }
+}
+
+void DapRpcSocket::setIODevice(QIODevice *pDevice)
+{
+ m_pDevice = pDevice;
+ connect(m_pDevice, SIGNAL(readyRead()), this, SLOT(processIncomingData()));
+}
+
+void DapRpcSocket::processRequestMessage(const DapRpcMessage &asMessage)
+{
+ processMessage(this, asMessage);
+}
diff --git a/dapRPCProtocol/DapRpcSocket.h b/dapRPCProtocol/DapRpcSocket.h
new file mode 100644
index 00000000..52aff7ac
--- /dev/null
+++ b/dapRPCProtocol/DapRpcSocket.h
@@ -0,0 +1,157 @@
+#ifndef DapRPCSOCKET_H
+#define DapRPCSOCKET_H
+
+#include <QObject>
+#include <QIODevice>
+#include <QPointer>
+#include <QTimer>
+#include <QEventLoop>
+#include <QDebug>
+#include <QJsonDocument>
+
+#include "DapRpcServiceProvider.h"
+#include "DapRpcMessage.h"
+#include "DapRpcServiceReply.h"
+
+#define DEFAULT_MSECS_REQUEST_TIMEOUT (30000)
+
+/**
+ * @brief The DapRpcSocket class
+ * Realization socket interface:
+ * - Store information about device and data
+ * - Sending/receiving messages
+ * - Control sending request by timeout
+ */
+class DapRpcSocket : public QObject, public DapRpcServiceProvider
+{
+ Q_OBJECT
+ Q_DISABLE_COPY(DapRpcSocket)
+
+ /// Pointer to IO device
+ QPointer<QIODevice> m_pDevice;
+ /// Buffer
+ QByteArray m_aBuffer;
+ /// Storage to replies by id
+ QHash<int, QPointer<DapRpcServiceReply>> m_replies;
+ /// Default request timeout
+ int m_defaultRequestTimeout;
+
+protected:
+ /// TODO: not implement
+ /// @param asMessage Request message
+ virtual void processRequestMessage(const DapRpcMessage &asMessage);
+
+public:
+ /// Standard constructor
+ explicit DapRpcSocket(QObject *apParent = nullptr);
+ /// Overloaded constructor
+ /// @param apDevice Device whick provides both a common implementation and
+ /// an abstract interface for devices that support reading and writing of blocks of data
+ explicit DapRpcSocket(QIODevice *apDevice, QObject *apParent = nullptr);
+ /// Virtual destructor
+ virtual ~DapRpcSocket();
+
+ /// Validation initialization and open device
+ /// @return True if device initilized and opened. Otherwise return false
+ virtual bool isValid() const;
+ /// Set default request timeout
+ /// @param aiMsecs Miliseconds
+ void setDefaultRequestTimeout(int aiMsecs);
+ /// Get default request timeout
+ /// @return Default request timeout
+ int getDefaultRequestTimeout() const;
+ /// Set IO Device
+ /// @param Pointer to IO device
+ void setIODevice(QIODevice *pDevice);
+
+signals:
+ /// The signal emitted when message was received
+ /// @param asMessage Request message
+ void messageReceived(const DapRpcMessage &asMessage);
+
+private slots:
+ /// Read data from device and prepare reply
+ virtual void processIncomingData();
+ /// Find end of Json document
+ /// @param aJsonData Json data where need to find end
+ /// @return Index of end json document. If file empty return -1
+ int findJsonDocumentEnd(const QByteArray &aJsonData);
+ /// Write data from message to device
+ /// @param asMessage Request message
+ void writeData(const DapRpcMessage &asMessage);
+
+public slots:
+ /// Notify to new request message and try to send to device
+ /// @param asMessage Request message
+ virtual void notify(const DapRpcMessage &asMessage);
+ /// Send message with delay for sending message
+ /// @param asMessage Request message
+ /// @param aMsecs Delay request timeout. If not pass parameter uses default value
+ /// @return Response from reply
+ virtual DapRpcMessage sendMessageBlocking(const DapRpcMessage &asMessage, int aMsecs = DEFAULT_MSECS_REQUEST_TIMEOUT);
+ /// Send request message to device
+ /// @param asMessage Request message
+ /// @return Pointer of service reply
+ virtual DapRpcServiceReply *sendMessage(const DapRpcMessage &asMessage);
+ /// Invoke remote method and create response to send to IO device with delay
+ /// @param asMethod Method's name
+ /// @param aMsecs Delay time for send
+ /// @param arg1 First argument
+ /// @param arg2 Second argument
+ /// @param arg3 Third argument
+ /// @param arg4 Fourth argument
+ /// @param arg5 Fifth argument
+ /// @param arg6 Six argument
+ /// @param arg7 Seven argument
+ /// @param arg8 Eight argument
+ /// @param arg9 Nine argument
+ /// @param arg10 Ten argument
+ /// @return Response from reply
+ DapRpcMessage invokeRemoteMethodBlocking(const QString &asMethod, int aMsecs, const QVariant &arg1 = QVariant(),
+ const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
+ const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
+ const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
+ const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
+ const QVariant &arg10 = QVariant());
+ /// Invoke remote method and create response to send to IO device with default delay time
+ /// @param asMethod Method's name
+ /// @param arg1 First argument
+ /// @param arg2 Second argument
+ /// @param arg3 Third argument
+ /// @param arg4 Fourth argument
+ /// @param arg5 Fifth argument
+ /// @param arg6 Six argument
+ /// @param arg7 Seven argument
+ /// @param arg8 Eight argument
+ /// @param arg9 Nine argument
+ /// @param arg10 Ten argument
+ /// @return Response from reply
+ DapRpcMessage invokeRemoteMethodBlocking(const QString &asMethod, const QVariant &arg1 = QVariant(),
+ const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
+ const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
+ const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
+ const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
+ const QVariant &arg10 = QVariant());
+ /// Invoke remote method and create response to send to IO device
+ /// @param asMethod Method's name
+ /// @param arg1 First argument
+ /// @param arg2 Second argument
+ /// @param arg3 Third argument
+ /// @param arg4 Fourth argument
+ /// @param arg5 Fifth argument
+ /// @param arg6 Six argument
+ /// @param arg7 Seven argument
+ /// @param arg8 Eight argument
+ /// @param arg9 Nine argument
+ /// @param arg10 Ten argument
+ /// @return Pointer to service reply
+ DapRpcServiceReply *invokeRemoteMethod(const QString &asMethod, const QVariant &arg1 = QVariant(),
+ const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
+ const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
+ const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
+ const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
+ const QVariant &arg10 = QVariant());
+ DapRpcServiceReply *invokeRemoteMethod(const DapRpcMessage &message);
+};
+
+#endif // DapRPCSOCKET_H
diff --git a/dapRPCProtocol/DapRpcTCPServer.cpp b/dapRPCProtocol/DapRpcTCPServer.cpp
new file mode 100644
index 00000000..ad70badf
--- /dev/null
+++ b/dapRPCProtocol/DapRpcTCPServer.cpp
@@ -0,0 +1,110 @@
+#include "DapRpcTCPServer.h"
+
+DapRpcTCPServer::DapRpcTCPServer(QObject *apParent)
+ : QTcpServer(apParent)
+{
+
+}
+
+DapRpcServiceReply *DapRpcTCPServer::notifyConnectedClients(const DapRpcMessage &message)
+{
+ DapRpcAbstractServer::notifyConnectedClients(message);
+}
+
+void DapRpcTCPServer::notifyConnectedClients(const QString &method, const QJsonArray ¶ms)
+{
+ DapRpcAbstractServer::notifyConnectedClients(method, params);
+}
+
+DapRpcTCPServer::~DapRpcTCPServer()
+{
+ foreach (QTcpSocket *socket, m_socketLookup.keys()) {
+ socket->flush();
+ socket->deleteLater();
+ }
+ m_socketLookup.clear();
+
+ foreach (DapRpcSocket *client, m_clients)
+ client->deleteLater();
+ m_clients.clear();
+}
+
+bool DapRpcTCPServer::listen(const QString &asAddress, quint16 aPort)
+{
+ return ((asAddress.isNull() || asAddress.isEmpty()) ?
+ QTcpServer::listen(QHostAddress::Any, aPort) :
+ QTcpServer::listen(QHostAddress(asAddress), aPort));
+}
+
+DapRpcService *DapRpcTCPServer::addService(DapRpcService *apService)
+{
+ if (!DapRpcServiceProvider::addService(apService))
+ return nullptr;
+
+ connect(apService, SIGNAL(notifyConnectedClients(DapRpcMessage)),
+ this, SLOT(notifyConnectedClients(DapRpcMessage)));
+ connect(apService, SIGNAL(notifyConnectedClients(QString,QJsonArray)),
+ this, SLOT(notifyConnectedClients(QString,QJsonArray)));
+ return apService;
+}
+
+bool DapRpcTCPServer::removeService(DapRpcService *apService)
+{
+ if (!DapRpcServiceProvider::removeService(apService))
+ return false;
+
+ disconnect(apService, SIGNAL(notifyConnectedClients(DapRpcMessage)),
+ this, SLOT(notifyConnectedClients(DapRpcMessage)));
+ disconnect(apService, SIGNAL(notifyConnectedClients(QString,QJsonArray)),
+ this, SLOT(notifyConnectedClients(QString,QJsonArray)));
+ return true;
+}
+
+void DapRpcTCPServer::clientDisconnected()
+{
+ QTcpSocket *tcpSocket = static_cast<QTcpSocket*>(sender());
+ if (!tcpSocket) {
+ qJsonRpcDebug() << "called with invalid socket";
+ return;
+ }
+
+ if (m_socketLookup.contains(tcpSocket)) {
+ DapRpcSocket *socket = m_socketLookup.take(tcpSocket);
+ m_clients.removeAll(socket);
+ socket->deleteLater();
+ }
+
+ tcpSocket->deleteLater();
+ emit onClientDisconnected();
+}
+
+void DapRpcTCPServer::messageProcessing(const DapRpcMessage &asMessage)
+{
+ DapRpcSocket *socket = static_cast<DapRpcSocket*>(sender());
+ if (!socket) {
+ qJsonRpcDebug() << "called without service socket";
+ return;
+ }
+
+ processMessage(socket, asMessage);
+}
+
+void DapRpcTCPServer::incomingConnection(qintptr aSocketDescriptor)
+{
+ QTcpSocket *tcpSocket = new QTcpSocket(this);
+ if (!tcpSocket->setSocketDescriptor(aSocketDescriptor))
+ {
+ qJsonRpcDebug() << "can't set socket descriptor";
+ tcpSocket->deleteLater();
+ return;
+ }
+
+ QIODevice *device = qobject_cast<QIODevice*>(tcpSocket);
+ DapRpcSocket *socket = new DapRpcSocket(device, this);
+ connect(socket, SIGNAL(messageReceived(DapRpcMessage)),
+ this, SLOT(_q_processMessage(DapRpcMessage)));
+ m_clients.append(socket);
+ connect(tcpSocket, SIGNAL(disconnected()), this, SLOT(_q_clientDisconnected()));
+ m_socketLookup.insert(tcpSocket, socket);
+ emit onClientConnected();
+}
diff --git a/dapRPCProtocol/DapRpcTCPServer.h b/dapRPCProtocol/DapRpcTCPServer.h
new file mode 100644
index 00000000..e2b0c59d
--- /dev/null
+++ b/dapRPCProtocol/DapRpcTCPServer.h
@@ -0,0 +1,76 @@
+#ifndef DapRPCTCPSERVER_H
+#define DapRPCTCPSERVER_H
+
+#include <QObject>
+#include <QTcpSocket>
+#include <QTcpServer>
+
+#include "DapRpcSocket.h"
+#include "DapRpcAbstractServer.h"
+
+/**
+ * @brief The DapRpcTCPServer class
+ * TCP server class realize interface DapRpcAbstractServer
+ * @see DapRpcAbstractServer
+ * @see QTcpServer
+ */
+class DapRpcTCPServer : public QTcpServer, public DapRpcAbstractServer
+{
+ Q_OBJECT
+ Q_DISABLE_COPY(DapRpcTCPServer)
+ /// Lookup's tcp sockets witj Rpc sockets
+ QHash<QTcpSocket*, DapRpcSocket*> m_socketLookup;
+
+protected:
+ /// This virtual function is called by QTcpServer when a new connection is available
+ /// @param aSocketDescriptor The socketDescriptor argument is the native socket
+ /// descriptor for the accepted connection
+ virtual void incomingConnection(qintptr aSocketDescriptor);
+
+public:
+ /// Standard constructor
+ explicit DapRpcTCPServer(QObject *apParent = nullptr);
+ /// Virtual destructor
+ virtual ~DapRpcTCPServer();
+
+ /// Tells the server to listen for incoming connections on address
+ /// @param asAddress Address
+ /// @param aPort Port. If port is 0, a port is chosen automatically
+ /// @param If address is QHostAddress::Any, the server will listen on all network interfaces
+ /// @return Returns true on success; otherwise returns false.
+ /// @see isListening()
+ virtual bool listen(const QString &asAddress = QString(), quint16 aPort = 0);
+ /// Add new service
+ /// @param apService New service
+ /// @return If service add successfully return true. Otherwise return false
+ DapRpcService * addService(DapRpcService *apService);
+ /// Remove service
+ /// @param apService Service for removing
+ /// @return If service add successfully return true. Otherwise return false
+ bool removeService(DapRpcService *apService);
+
+signals:
+ /// The signal is emitted when client was connected
+ void onClientConnected();
+ /// The signal is emitted when client was disconnected
+ void onClientDisconnected();
+
+protected slots:
+ /// Calls when client disconnected
+ void clientDisconnected();
+ /// When receive message from client prepare message by type of message
+ /// @param asMessage Message
+ void messageProcessing(const DapRpcMessage &asMessage);
+
+ // DapRpcAbstractServer interface
+public slots:
+ /// Notify connected clients. Send all message
+ /// @param message Message to client
+ DapRpcServiceReply* notifyConnectedClients(const DapRpcMessage &message);
+ /// Notify connected clients. Send all message
+ /// @param method Method which clients were notified
+ /// @param params Parameters of message in JSON format
+ void notifyConnectedClients(const QString &method, const QJsonArray ¶ms);
+};
+
+#endif // DapRPCTCPSERVER_H
diff --git a/handlers/DapAbstractCommand.cpp b/handlers/DapAbstractCommand.cpp
new file mode 100644
index 00000000..fa1ab221
--- /dev/null
+++ b/handlers/DapAbstractCommand.cpp
@@ -0,0 +1,232 @@
+#include "DapAbstractCommand.h"
+
+/// Overloaded constructor.
+/// @param asServiceName Service name.
+/// @param parent Parent.
+/// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+/// @param asCliPath The path to cli nodes.
+DapAbstractCommand::DapAbstractCommand(const QString &asServiceName, QObject *parent, const QString &asCliPath)
+ : DapCommand(asServiceName, parent), m_parent(parent), m_sCliPath(asCliPath)
+{
+
+}
+
+/// Send a notification to the client. At the same time, you should not expect a response from the client.
+/// @details Performed on the service side.
+/// @param arg1...arg10 Parameters.
+void DapAbstractCommand::notifyToClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3,
+ const QVariant &arg4, const QVariant &arg5, const QVariant &arg6,
+ const QVariant &arg7, const QVariant &arg8, const QVariant &arg9,
+ const QVariant &arg10)
+{
+ QVariantList params;
+ if (arg1.isValid()) params.append(arg1);
+ if (arg2.isValid()) params.append(arg2);
+ if (arg3.isValid()) params.append(arg3);
+ if (arg4.isValid()) params.append(arg4);
+ if (arg5.isValid()) params.append(arg5);
+ if (arg6.isValid()) params.append(arg6);
+ if (arg7.isValid()) params.append(arg7);
+ if (arg8.isValid()) params.append(arg8);
+ if (arg9.isValid()) params.append(arg9);
+ if (arg10.isValid()) params.append(arg10);
+
+ DapRpcLocalServer * server = dynamic_cast<DapRpcLocalServer *>(m_parent);
+
+ Q_ASSERT(server);
+
+ DapRpcMessage request = DapRpcMessage::createNotification(QString("%1.%2").arg(this->getName()).arg("notifedFromService"), QJsonArray::fromVariantList(params));
+ server->notifyConnectedClients(request);
+}
+
+/// Process the notification from the service on the client side.
+/// @details Performed on the client side.
+/// @param arg1...arg10 Parameters.
+void DapAbstractCommand::notifedFromService(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3,
+ const QVariant &arg4, const QVariant &arg5, const QVariant &arg6,
+ const QVariant &arg7, const QVariant &arg8, const QVariant &arg9,
+ const QVariant &arg10)
+{
+ Q_UNUSED(arg1);
+ Q_UNUSED(arg2);
+ Q_UNUSED(arg3);
+ Q_UNUSED(arg4);
+ Q_UNUSED(arg5);
+ Q_UNUSED(arg6);
+ Q_UNUSED(arg7);
+ Q_UNUSED(arg8);
+ Q_UNUSED(arg9);
+ Q_UNUSED(arg10);
+
+ emit clientNotifed(QVariant());
+}
+
+/// Send request to client.
+/// @details Performed on the service side.
+/// @param arg1...arg10 Parameters.
+void DapAbstractCommand::requestToClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3,
+ const QVariant &arg4, const QVariant &arg5, const QVariant &arg6,
+ const QVariant &arg7, const QVariant &arg8, const QVariant &arg9,
+ const QVariant &arg10)
+{
+ QVariantList params;
+ if (arg1.isValid()) params.append(arg1);
+ if (arg2.isValid()) params.append(arg2);
+ if (arg3.isValid()) params.append(arg3);
+ if (arg4.isValid()) params.append(arg4);
+ if (arg5.isValid()) params.append(arg5);
+ if (arg6.isValid()) params.append(arg6);
+ if (arg7.isValid()) params.append(arg7);
+ if (arg8.isValid()) params.append(arg8);
+ if (arg9.isValid()) params.append(arg9);
+ if (arg10.isValid()) params.append(arg10);
+
+ DapRpcLocalServer * server = dynamic_cast<DapRpcLocalServer *>(m_parent);
+
+ Q_ASSERT(server);
+
+ DapRpcMessage request = DapRpcMessage::createRequest(QString("%1.%2").arg(this->getName()).arg("respondToService"), QJsonArray::fromVariantList(params));
+ DapRpcServiceReply * reply = server->notifyConnectedClients(request);
+ connect(reply, SIGNAL(finished()), this, SLOT(replyFromClient()));
+}
+
+/// Send a response to the service.
+/// @details Performed on the client side.
+/// @param arg1...arg10 Parameters.
+/// @return Reply to service.
+QVariant DapAbstractCommand::respondToService(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3,
+ const QVariant &arg4, const QVariant &arg5, const QVariant &arg6,
+ const QVariant &arg7, const QVariant &arg8, const QVariant &arg9,
+ const QVariant &arg10)
+{
+ Q_UNUSED(arg1)
+ Q_UNUSED(arg2)
+ Q_UNUSED(arg3)
+ Q_UNUSED(arg4)
+ Q_UNUSED(arg5)
+ Q_UNUSED(arg6)
+ Q_UNUSED(arg7)
+ Q_UNUSED(arg8)
+ Q_UNUSED(arg9)
+ Q_UNUSED(arg10)
+
+ return QVariant();
+}
+
+/// Reply from client.
+/// @details Performed on the service side.
+/// @return Client reply.
+QVariant DapAbstractCommand::replyFromClient()
+{
+ DapRpcServiceReply *reply = static_cast<DapRpcServiceReply *>(sender());
+ emit clientResponded(reply->response().toJsonValue().toVariant());
+ return QVariant();
+}
+
+/// Send a notification to the service. At the same time, you should not expect a response from the service.
+/// @details Performed on the client side.
+/// @param arg1...arg10 Parameters.
+void DapAbstractCommand::notifyToService(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3,
+ const QVariant &arg4, const QVariant &arg5, const QVariant &arg6,
+ const QVariant &arg7, const QVariant &arg8, const QVariant &arg9,
+ const QVariant &arg10)
+{
+ QVariantList params;
+ if (arg1.isValid()) params.append(arg1);
+ if (arg2.isValid()) params.append(arg2);
+ if (arg3.isValid()) params.append(arg3);
+ if (arg4.isValid()) params.append(arg4);
+ if (arg5.isValid()) params.append(arg5);
+ if (arg6.isValid()) params.append(arg6);
+ if (arg7.isValid()) params.append(arg7);
+ if (arg8.isValid()) params.append(arg8);
+ if (arg9.isValid()) params.append(arg9);
+ if (arg10.isValid()) params.append(arg10);
+
+ DapRpcSocket * socket = dynamic_cast<DapRpcSocket *>(m_parent);
+
+ Q_ASSERT(socket);
+
+ DapRpcMessage notify = DapRpcMessage::createNotification(QString("%1.%2").arg(this->getName()).arg("notifedFromClient"), QJsonArray::fromVariantList(params));
+ socket->notify(notify);
+}
+
+/// Process the notification from the client on the service side.
+/// @details Performed on the service side.
+/// @param arg1...arg10 Parameters.
+void DapAbstractCommand::notifedFromClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3, const QVariant &arg4, const QVariant &arg5, const QVariant &arg6, const QVariant &arg7, const QVariant &arg8, const QVariant &arg9, const QVariant &arg10)
+{
+ Q_UNUSED(arg1);
+ Q_UNUSED(arg2);
+ Q_UNUSED(arg3);
+ Q_UNUSED(arg4);
+ Q_UNUSED(arg5);
+ Q_UNUSED(arg6);
+ Q_UNUSED(arg7);
+ Q_UNUSED(arg8);
+ Q_UNUSED(arg9);
+ Q_UNUSED(arg10);
+
+ emit serviceNotifed(QVariant());
+}
+
+/// Send request to service.
+/// @details Performed on the client side.
+/// @param arg1...arg10 Parameters.
+void DapAbstractCommand::requestToService(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3,
+ const QVariant &arg4, const QVariant &arg5,
+ const QVariant &arg6, const QVariant &arg7,
+ const QVariant &arg8, const QVariant &arg9,
+ const QVariant &arg10)
+{
+ QVariantList params;
+ if (arg1.isValid()) params.append(arg1);
+ if (arg2.isValid()) params.append(arg2);
+ if (arg3.isValid()) params.append(arg3);
+ if (arg4.isValid()) params.append(arg4);
+ if (arg5.isValid()) params.append(arg5);
+ if (arg6.isValid()) params.append(arg6);
+ if (arg7.isValid()) params.append(arg7);
+ if (arg8.isValid()) params.append(arg8);
+ if (arg9.isValid()) params.append(arg9);
+ if (arg10.isValid()) params.append(arg10);
+
+ DapRpcServiceReply *reply = dynamic_cast<DapRpcSocket *>(m_parent)->invokeRemoteMethod(QString("%1.%2").arg(this->getName()).arg("respondToClient"),
+ arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+ connect(reply, SIGNAL(finished()), this, SLOT(replyFromService()));
+}
+
+/// Send a response to the client.
+/// @details Performed on the service side.
+/// @param arg1...arg10 Parameters.
+/// @return Reply to client.
+QVariant DapAbstractCommand::respondToClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3,
+ const QVariant &arg4, const QVariant &arg5, const QVariant &arg6,
+ const QVariant &arg7, const QVariant &arg8, const QVariant &arg9,
+ const QVariant &arg10)
+{
+ Q_UNUSED(arg1)
+ Q_UNUSED(arg2)
+ Q_UNUSED(arg3)
+ Q_UNUSED(arg4)
+ Q_UNUSED(arg5)
+ Q_UNUSED(arg6)
+ Q_UNUSED(arg7)
+ Q_UNUSED(arg8)
+ Q_UNUSED(arg9)
+ Q_UNUSED(arg10)
+
+ return QVariant();
+}
+
+/// Reply from service.
+/// @details Performed on the service side.
+/// @return Service reply.
+QVariant DapAbstractCommand::replyFromService()
+{
+ DapRpcServiceReply *reply = static_cast<DapRpcServiceReply *>(sender());
+
+ emit serviceResponded(reply->response().toJsonValue().toVariant());
+
+ return reply->response().toJsonValue().toVariant();
+}
diff --git a/handlers/DapAbstractCommand.h b/handlers/DapAbstractCommand.h
new file mode 100644
index 00000000..70b2d982
--- /dev/null
+++ b/handlers/DapAbstractCommand.h
@@ -0,0 +1,138 @@
+/****************************************************************************
+**
+** This file is part of the libdap-qt-ui-chain-wallet library.
+**
+** The class implements the command interface.
+**
+****************************************************************************/
+
+#ifndef DAPABSTRACTCOMMAND_H
+#define DAPABSTRACTCOMMAND_H
+
+#include <QObject>
+#include <QVariant>
+
+#include "DapRpcSocket.h"
+#include "DapRpcLocalServer.h"
+
+typedef DapRpcService DapCommand;
+
+class DapAbstractCommand : public DapCommand
+{
+ Q_OBJECT
+
+protected:
+ /// Parent.
+ QObject * m_parent {nullptr};
+ /// The path to cli nodes.
+ QString m_sCliPath;
+ /// Overloaded constructor.
+ /// @param asServiceName Service name.
+ /// @param parent Parent.
+ /// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+ /// @param asCliPath The path to cli nodes.
+ explicit DapAbstractCommand(const QString &asServiceName, QObject *parent = nullptr, const QString &asCliPath = QString());
+
+signals:
+ /// The signal is emitted in case of successful notification of the client by the service.
+ /// @param aNotify Notification.
+ void clientNotifed(const QVariant& aNotify);
+ /// The signal is emitted if the client has successfully received
+ /// a request from the service and responded to the service.
+ /// @param asRespond Client response.
+ void clientResponded(const QVariant& aRespond);
+ /// The signal is emitted if the client successfully notifies the service.
+ /// @param aNotify Notification.
+ void serviceNotifed(const QVariant& aNotify);
+ /// The signal is emitted if the service has successfully received
+ /// a request from the client and responded to the client
+ /// @param asRespond Service response.
+ void serviceResponded(const QVariant& aRespond);
+
+public slots:
+ /// Send a notification to the client. At the same time, you should not expect a response from the client.
+ /// @details Performed on the service side.
+ /// @param arg1...arg10 Parameters.
+ Q_INVOKABLE virtual void notifyToClient(const QVariant &arg1 = QVariant(),
+ const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
+ const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
+ const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
+ const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
+ const QVariant &arg10 = QVariant());
+ /// Process the notification from the service on the client side.
+ /// @details Performed on the client side.
+ /// @param arg1...arg10 Parameters.
+ Q_INVOKABLE virtual void notifedFromService(const QVariant &arg1 = QVariant(),
+ const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
+ const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
+ const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
+ const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
+ const QVariant &arg10 = QVariant());
+ /// Send request to client.
+ /// @details Performed on the service side.
+ /// @param arg1...arg10 Parameters.
+ Q_INVOKABLE virtual void requestToClient(const QVariant &arg1 = QVariant(),
+ const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
+ const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
+ const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
+ const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
+ const QVariant &arg10 = QVariant());
+ /// Send a response to the service.
+ /// @details Performed on the client side.
+ /// @param arg1...arg10 Parameters.
+ /// @return Reply to service.
+ virtual QVariant respondToService(const QVariant &arg1 = QVariant(),
+ const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
+ const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
+ const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
+ const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
+ const QVariant &arg10 = QVariant());
+ /// Reply from client.
+ /// @details Performed on the service side.
+ /// @return Client reply.
+ virtual QVariant replyFromClient();
+
+ /// Send a notification to the service. At the same time, you should not expect a response from the service.
+ /// @details Performed on the client side.
+ /// @param arg1...arg10 Parameters.
+ Q_INVOKABLE virtual void notifyToService(const QVariant &arg1 = QVariant(),
+ const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
+ const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
+ const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
+ const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
+ const QVariant &arg10 = QVariant());
+ /// Process the notification from the client on the service side.
+ /// @details Performed on the service side.
+ /// @param arg1...arg10 Parameters.
+ Q_INVOKABLE virtual void notifedFromClient(const QVariant &arg1 = QVariant(),
+ const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
+ const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
+ const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
+ const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
+ const QVariant &arg10 = QVariant());
+ /// Send request to service.
+ /// @details Performed on the client side.
+ /// @param arg1...arg10 Parameters.
+ Q_INVOKABLE virtual void requestToService(const QVariant &arg1 = QVariant(),
+ const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
+ const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
+ const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
+ const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
+ const QVariant &arg10 = QVariant());
+ /// Send a response to the client.
+ /// @details Performed on the service side.
+ /// @param arg1...arg10 Parameters.
+ /// @return Reply to client.
+ virtual QVariant respondToClient(const QVariant &arg1 = QVariant(),
+ const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
+ const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
+ const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
+ const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
+ const QVariant &arg10 = QVariant());
+ /// Reply from service.
+ /// @details Performed on the service side.
+ /// @return Service reply.
+ virtual QVariant replyFromService();
+};
+
+#endif // DAPABSTRACTCOMMAND_H
diff --git a/handlers/DapActivateClientCommand.cpp b/handlers/DapActivateClientCommand.cpp
new file mode 100644
index 00000000..9c1a2fa9
--- /dev/null
+++ b/handlers/DapActivateClientCommand.cpp
@@ -0,0 +1,13 @@
+#include "DapActivateClientCommand.h"
+
+/// Overloaded constructor.
+/// @param asServiceName Service name.
+/// @param parent Parent.
+/// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+DapActivateClientCommand::DapActivateClientCommand(const QString &asServicename, QObject *parent)
+ : DapAbstractCommand(asServicename, parent)
+{
+
+}
+
+
diff --git a/handlers/DapActivateClientCommand.h b/handlers/DapActivateClientCommand.h
new file mode 100644
index 00000000..05e8f1c4
--- /dev/null
+++ b/handlers/DapActivateClientCommand.h
@@ -0,0 +1,28 @@
+/****************************************************************************
+**
+** This file is part of the libdap-qt-ui-chain-wallet library.
+**
+** The class implements the command to activate the GUI client. That is,
+** by clicking on the icon in the system tray, the main window of the GUI
+** client is minimized / expanded.
+**
+****************************************************************************/
+
+#ifndef DAPACTIVATECLIENTCOMMAND_H
+#define DAPACTIVATECLIENTCOMMAND_H
+
+#include <QObject>
+
+#include "DapAbstractCommand.h"
+
+class DapActivateClientCommand : public DapAbstractCommand
+{
+public:
+ /// Overloaded constructor.
+ /// @param asServiceName Service name.
+ /// @param parent Parent.
+ /// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+ DapActivateClientCommand(const QString &asServicename, QObject *parent = nullptr);
+};
+
+#endif // DAPACTIVATECLIENTCOMMAND_H
diff --git a/handlers/DapAddWalletCommand.cpp b/handlers/DapAddWalletCommand.cpp
new file mode 100644
index 00000000..0570ed61
--- /dev/null
+++ b/handlers/DapAddWalletCommand.cpp
@@ -0,0 +1,46 @@
+#include "DapAddWalletCommand.h"
+
+/// Overloaded constructor.
+/// @param asServiceName Service name.
+/// @param parent Parent.
+/// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+DapAddWalletCommand::DapAddWalletCommand(const QString &asServicename, QObject *parent)
+ : DapAbstractCommand(asServicename, parent)
+{
+
+}
+
+/// Send a response to the client.
+/// @details Performed on the service side.
+/// @param arg1...arg10 Parameters.
+/// @return Reply to client.
+QVariant DapAddWalletCommand::respondToClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3,
+ const QVariant &arg4, const QVariant &arg5, const QVariant &arg6,
+ const QVariant &arg7, const QVariant &arg8, const QVariant &arg9,
+ const QVariant &arg10)
+{
+ Q_UNUSED(arg5)
+ Q_UNUSED(arg6)
+ Q_UNUSED(arg7)
+ Q_UNUSED(arg8)
+ Q_UNUSED(arg9)
+ Q_UNUSED(arg10)
+
+ QProcess process;
+ QJsonArray result;
+ process.start(QString("%1 wallet new -w %2 -sign %3 -net %4 -restore %5").arg(CLI_PATH).arg(arg1.toString()).arg(arg2.toString()).arg(arg3.toString()).arg(arg4.toString()));
+ process.waitForFinished(-1);
+ QString resources = QString::fromLatin1(process.readAll());
+ if(resources.contains("already exists"))
+ {
+ result.append(QJsonValue(false));
+ result.append(QJsonValue("Wallet already exists"));
+ }
+ else
+ {
+ result.append(QJsonValue(true));
+ result.append(QJsonValue(arg1.toString()));
+ result.append(QJsonValue("Wallet successfully created"));
+ }
+ return result.toVariantList();
+}
diff --git a/handlers/DapAddWalletCommand.h b/handlers/DapAddWalletCommand.h
new file mode 100644
index 00000000..f76cc0d6
--- /dev/null
+++ b/handlers/DapAddWalletCommand.h
@@ -0,0 +1,38 @@
+/****************************************************************************
+**
+** This file is part of the libdap-qt-ui-chain-wallet library.
+**
+** The class implements the functionality of creating a new wallet.
+**
+****************************************************************************/
+
+#ifndef DAPADDWALLETCOMMAND_H
+#define DAPADDWALLETCOMMAND_H
+
+#include <QProcess>
+#include <QString>
+
+#include "DapAbstractCommand.h"
+
+class DapAddWalletCommand : public DapAbstractCommand
+{
+public:
+ /// Overloaded constructor.
+ /// @param asServiceName Service name.
+ /// @param parent Parent.
+ /// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+ explicit DapAddWalletCommand(const QString &asServicename, QObject *parent = nullptr);
+
+public slots:
+ /// Send a response to the client.
+ /// @details Performed on the service side.
+ /// @param arg1...arg10 Parameters.
+ /// @return Reply to client.
+ QVariant respondToClient(const QVariant &arg1 = QVariant(), const QVariant &arg2 = QVariant(),
+ const QVariant &arg3 = QVariant(), const QVariant &arg4 = QVariant(),
+ const QVariant &arg5 = QVariant(), const QVariant &arg6 = QVariant(),
+ const QVariant &arg7 = QVariant(), const QVariant &arg8 = QVariant(),
+ const QVariant &arg9 = QVariant(), const QVariant &arg10 = QVariant());
+};
+
+#endif // DAPADDWALLETCOMMAND_H
diff --git a/handlers/DapCreateTransactionCommand.cpp b/handlers/DapCreateTransactionCommand.cpp
new file mode 100644
index 00000000..ba563b0e
--- /dev/null
+++ b/handlers/DapCreateTransactionCommand.cpp
@@ -0,0 +1,51 @@
+#include "DapCreateTransactionCommand.h"
+
+/// Overloaded constructor.
+/// @param asServiceName Service name.
+/// @param parent Parent.
+/// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+/// @param asCliPath The path to cli nodes.
+DapCreateTransactionCommand::DapCreateTransactionCommand(const QString &asServicename, QObject *parent, const QString &asCliPath)
+ : DapAbstractCommand(asServicename, parent, asCliPath)
+{
+
+}
+
+/// Send a response to the client.
+/// @details Performed on the service side.
+/// @param arg1 Network.
+/// @param arg2 Chain.
+/// @param arg3 Wallet sender.
+/// @param arg4 Recipient's wallet address.
+/// @param arg5 Token.
+/// @param arg6 Transfer amount.
+/// @return Reply to client.
+QVariant DapCreateTransactionCommand::respondToClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3, const QVariant &arg4, const QVariant &arg5, const QVariant &arg6, const QVariant &arg7, const QVariant &arg8, const QVariant &arg9, const QVariant &arg10)
+{
+ Q_UNUSED(arg7)
+ Q_UNUSED(arg8)
+ Q_UNUSED(arg9)
+ Q_UNUSED(arg10)
+
+ QProcess processCreate;
+ processCreate.start(QString("%1 tx_create -net %2 -chain %3 -from_wallet %4 -to_addr %5 -token %6 -value %7")
+ .arg(m_sCliPath)
+ .arg(arg1.toString())
+ .arg(arg2.toString())
+ .arg(arg3.toString())
+ .arg(arg4.toString())
+ .arg(arg5.toString())
+ .arg(arg6.toString()));
+
+ processCreate.waitForFinished(-1);
+ QByteArray result = processCreate.readAll();
+
+ QRegExp rx("transfer=(\\w+)");
+ rx.indexIn(result, 0);
+
+ if(rx.cap(1) == "Ok")
+ {
+ return true;
+ }
+ return false;
+}
diff --git a/handlers/DapCreateTransactionCommand.h b/handlers/DapCreateTransactionCommand.h
new file mode 100644
index 00000000..de3ec674
--- /dev/null
+++ b/handlers/DapCreateTransactionCommand.h
@@ -0,0 +1,35 @@
+#ifndef DAPCREATETRANSACTIONCOMMAND_H
+#define DAPCREATETRANSACTIONCOMMAND_H
+
+#include <QProcess>
+
+#include "DapAbstractCommand.h"
+
+class DapCreateTransactionCommand : public DapAbstractCommand
+{
+public:
+ /// Overloaded constructor.
+ /// @param asServiceName Service name.
+ /// @param parent Parent.
+ /// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+ /// @param asCliPath The path to cli nodes.
+ DapCreateTransactionCommand(const QString &asServicename, QObject *parent = nullptr, const QString &asCliPath = QString());
+
+public slots:
+ /// Send a response to the client.
+ /// @details Performed on the service side.
+ /// @param arg1 Network.
+ /// @param arg2 Chain.
+ /// @param arg3 Wallet sender.
+ /// @param arg4 Recipient's wallet address.
+ /// @param arg5 Token.
+ /// @param arg6 Transfer amount.
+ /// @return Reply to client.
+ QVariant respondToClient(const QVariant &arg1 = QVariant(), const QVariant &arg2 = QVariant(),
+ const QVariant &arg3 = QVariant(), const QVariant &arg4 = QVariant(),
+ const QVariant &arg5 = QVariant(), const QVariant &arg6 = QVariant(),
+ const QVariant &arg7 = QVariant(), const QVariant &arg8 = QVariant(),
+ const QVariant &arg9 = QVariant(), const QVariant &arg10 = QVariant()) override;
+};
+
+#endif // DAPCREATETRANSACTIONCOMMAND_H
diff --git a/handlers/DapExportLogCommand.cpp b/handlers/DapExportLogCommand.cpp
new file mode 100644
index 00000000..9f26d85d
--- /dev/null
+++ b/handlers/DapExportLogCommand.cpp
@@ -0,0 +1,42 @@
+#include "DapExportLogCommand.h"
+
+/// Overloaded constructor.
+/// @param asServiceName Service name.
+/// @param apSocket Client connection socket with service.
+/// @param parent Parent.
+DapExportLogCommand::DapExportLogCommand(const QString &asServicename, QObject *parent)
+ : DapAbstractCommand(asServicename, parent)
+{
+
+}
+
+/// Send a response to the client.
+/// A log file is saved from the GUI window.
+/// @param arg1...arg10 Parameters.
+/// @return Reply to client.
+QVariant DapExportLogCommand::respondToClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3,
+ const QVariant &arg4, const QVariant &arg5, const QVariant &arg6,
+ const QVariant &arg7, const QVariant &arg8, const QVariant &arg9,
+ const QVariant &arg10)
+{
+ Q_UNUSED(arg3)
+ Q_UNUSED(arg4)
+ Q_UNUSED(arg5)
+ Q_UNUSED(arg6)
+ Q_UNUSED(arg7)
+ Q_UNUSED(arg8)
+ Q_UNUSED(arg9)
+ Q_UNUSED(arg10)
+
+ QFile saveDapLog(arg1.toString());
+ if (!saveDapLog.open(QIODevice::WriteOnly | QIODevice::Text))
+ {
+ qCritical("The file does not write.");
+ return false;
+ }
+ QTextStream saveLog(&saveDapLog);
+ saveLog << arg2.toString();
+
+ saveDapLog.close();
+ return QVariant();
+}
diff --git a/handlers/DapExportLogCommand.h b/handlers/DapExportLogCommand.h
new file mode 100644
index 00000000..79d21af1
--- /dev/null
+++ b/handlers/DapExportLogCommand.h
@@ -0,0 +1,30 @@
+#ifndef DAPSAVELOGCOMMAND_H
+#define DAPSAVELOGCOMMAND_H
+
+#include <QFile>
+
+#include "DapAbstractCommand.h"
+
+class DapExportLogCommand : public DapAbstractCommand
+{
+
+public:
+ /// Overloaded constructor.
+ /// @param asServiceName Service name.
+ /// @param apSocket Client connection socket with service.
+ /// @param parent Parent.
+ explicit DapExportLogCommand(const QString &asServicename, QObject *parent = nullptr);
+
+public slots:
+ /// Send a response to the client.
+ /// /// A log file is saved from the GUI window.
+ /// @param arg1...arg10 Parameters.
+ /// @return Reply to client.
+ QVariant respondToClient(const QVariant &arg1 = QVariant(), const QVariant &arg2 = QVariant(),
+ const QVariant &arg3 = QVariant(), const QVariant &arg4 = QVariant(),
+ const QVariant &arg5 = QVariant(), const QVariant &arg6 = QVariant(),
+ const QVariant &arg7 = QVariant(), const QVariant &arg8 = QVariant(),
+ const QVariant &arg9 = QVariant(), const QVariant &arg10 = QVariant()) override;
+};
+
+#endif // DAPSAVELOGCOMMAND_H
diff --git a/handlers/DapGetHistoryExecutedCmdCommand.cpp b/handlers/DapGetHistoryExecutedCmdCommand.cpp
new file mode 100644
index 00000000..9c10cb29
--- /dev/null
+++ b/handlers/DapGetHistoryExecutedCmdCommand.cpp
@@ -0,0 +1,48 @@
+#include "DapGetHistoryExecutedCmdCommand.h"
+
+/// Overloaded constructor.
+/// @param asServiceName Service name.
+/// @param parent Parent.
+/// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+/// @param asCliPath The path to cli nodes.
+DapGetHistoryExecutedCmdCommand::DapGetHistoryExecutedCmdCommand(const QString &asServicename, QObject *parent, const QString &asCliPath)
+ : DapAbstractCommand(asServicename, parent, asCliPath)
+{
+ DapRpcLocalServer * server = dynamic_cast<DapRpcLocalServer *>(m_parent);
+ if(server)
+ {
+ QDir().mkpath(QFileInfo(asCliPath).path());
+ m_File = new QFile(asCliPath, this);
+ }
+}
+
+/// Send a response to the client.
+/// @details Performed on the service side.
+/// @param arg1...arg10 Parameters.
+/// @return Reply to client.
+QVariant DapGetHistoryExecutedCmdCommand::respondToClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3, const QVariant &arg4, const QVariant &arg5, const QVariant &arg6, const QVariant &arg7, const QVariant &arg8, const QVariant &arg9, const QVariant &arg10)
+{
+ Q_UNUSED(arg1)
+ Q_UNUSED(arg2)
+ Q_UNUSED(arg3)
+ Q_UNUSED(arg4)
+ Q_UNUSED(arg5)
+ Q_UNUSED(arg6)
+ Q_UNUSED(arg7)
+ Q_UNUSED(arg8)
+ Q_UNUSED(arg9)
+ Q_UNUSED(arg10)
+
+ QJsonArray historyExecutedCmd;
+
+ if(!m_File->open(QIODevice::ReadOnly | QIODevice::Text))
+ return historyExecutedCmd;
+
+ while (!m_File->atEnd())
+ {
+ historyExecutedCmd.append(QJsonValue(QString::fromLatin1(m_File->readLine()).trimmed()));
+ }
+ m_File->close();
+
+ return historyExecutedCmd;
+}
diff --git a/handlers/DapGetHistoryExecutedCmdCommand.h b/handlers/DapGetHistoryExecutedCmdCommand.h
new file mode 100644
index 00000000..df760d19
--- /dev/null
+++ b/handlers/DapGetHistoryExecutedCmdCommand.h
@@ -0,0 +1,35 @@
+#ifndef DAPGETHISTORYEXECUTEDCMDCOMMAND_H
+#define DAPGETHISTORYEXECUTEDCMDCOMMAND_H
+
+#include <QProcess>
+#include <QFile>
+#include <QDir>
+
+#include "DapAbstractCommand.h"
+
+class DapGetHistoryExecutedCmdCommand : public DapAbstractCommand
+{
+ /// Command history file.
+ QFile * m_File {nullptr};
+
+public:
+ /// Overloaded constructor.
+ /// @param asServiceName Service name.
+ /// @param parent Parent.
+ /// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+ /// @param asCliPath The path to cli nodes.
+ DapGetHistoryExecutedCmdCommand(const QString &asServicename, QObject *parent = nullptr, const QString &asCliPath = QString());
+
+public slots:
+ /// Send a response to the client.
+ /// @details Performed on the service side.
+ /// @param arg1...arg10 Parameters.
+ /// @return Reply to client.
+ QVariant respondToClient(const QVariant &arg1 = QVariant(), const QVariant &arg2 = QVariant(),
+ const QVariant &arg3 = QVariant(), const QVariant &arg4 = QVariant(),
+ const QVariant &arg5 = QVariant(), const QVariant &arg6 = QVariant(),
+ const QVariant &arg7 = QVariant(), const QVariant &arg8 = QVariant(),
+ const QVariant &arg9 = QVariant(), const QVariant &arg10 = QVariant()) override;
+};
+
+#endif // DAPGETHISTORYEXECUTEDCMDCOMMAND_H
diff --git a/handlers/DapGetListNetworksCommand.cpp b/handlers/DapGetListNetworksCommand.cpp
new file mode 100644
index 00000000..79adcecf
--- /dev/null
+++ b/handlers/DapGetListNetworksCommand.cpp
@@ -0,0 +1,42 @@
+#include "DapGetListNetworksCommand.h"
+
+/// Overloaded constructor.
+/// @param asServiceName Service name.
+/// @param parent Parent.
+/// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+/// @param asCliPath The path to cli nodes.
+DapGetListNetworksCommand::DapGetListNetworksCommand(const QString &asServicename, QObject *parent, const QString &asCliPath)
+ : DapAbstractCommand(asServicename, parent, asCliPath)
+{
+
+}
+
+/// Send a response to the client.
+/// @details Performed on the service side.
+/// @param arg1...arg10 Parameters.
+/// @return Reply to client.
+QVariant DapGetListNetworksCommand::respondToClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3, const QVariant &arg4, const QVariant &arg5, const QVariant &arg6, const QVariant &arg7, const QVariant &arg8, const QVariant &arg9, const QVariant &arg10)
+{
+ Q_UNUSED(arg1)
+ Q_UNUSED(arg2)
+ Q_UNUSED(arg3)
+ Q_UNUSED(arg4)
+ Q_UNUSED(arg5)
+ Q_UNUSED(arg6)
+ Q_UNUSED(arg7)
+ Q_UNUSED(arg8)
+ Q_UNUSED(arg9)
+ Q_UNUSED(arg10)
+
+ QStringList networkList;
+ QProcess process;
+ process.start(QString("%1 net list").arg(m_sCliPath));
+ process.waitForFinished(-1);
+ QString result = QString::fromLatin1(process.readAll());
+ if(!(result.isEmpty() || result.isNull() || result.contains('\'')))
+ {
+ QStringList str = result.remove(" ").remove("\n").remove("\r").split(":").at(1).split(",");
+ return str;
+ }
+ return QString();
+}
diff --git a/handlers/DapGetListNetworksCommand.h b/handlers/DapGetListNetworksCommand.h
new file mode 100644
index 00000000..ecfac60c
--- /dev/null
+++ b/handlers/DapGetListNetworksCommand.h
@@ -0,0 +1,30 @@
+#ifndef DAPGETLISTNETWORKSCOMMAND_H
+#define DAPGETLISTNETWORKSCOMMAND_H
+
+#include <QProcess>
+
+#include "DapAbstractCommand.h"
+
+class DapGetListNetworksCommand : public DapAbstractCommand
+{
+public:
+ /// Overloaded constructor.
+ /// @param asServiceName Service name.
+ /// @param parent Parent.
+ /// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+ /// @param asCliPath The path to cli nodes.
+ DapGetListNetworksCommand(const QString &asServicename, QObject *parent = nullptr, const QString &asCliPath = QString());
+
+public slots:
+ /// Send a response to the client.
+ /// @details Performed on the service side.
+ /// @param arg1...arg10 Parameters.
+ /// @return Reply to client.
+ QVariant respondToClient(const QVariant &arg1 = QVariant(), const QVariant &arg2 = QVariant(),
+ const QVariant &arg3 = QVariant(), const QVariant &arg4 = QVariant(),
+ const QVariant &arg5 = QVariant(), const QVariant &arg6 = QVariant(),
+ const QVariant &arg7 = QVariant(), const QVariant &arg8 = QVariant(),
+ const QVariant &arg9 = QVariant(), const QVariant &arg10 = QVariant()) override;
+};
+
+#endif // DAPGETLISTNETWORKSCOMMAND_H
diff --git a/handlers/DapGetListWalletsCommand.cpp b/handlers/DapGetListWalletsCommand.cpp
new file mode 100644
index 00000000..a2f514ec
--- /dev/null
+++ b/handlers/DapGetListWalletsCommand.cpp
@@ -0,0 +1,49 @@
+#include "DapGetListWalletsCommand.h"
+
+/// Overloaded constructor.
+/// @param asServiceName Service name.
+/// @param parent Parent.
+/// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+/// @param asCliPath The path to cli nodes.
+DapGetListWalletsCommand::DapGetListWalletsCommand(const QString &asServicename, QObject *parent, const QString &asCliPath)
+ : DapAbstractCommand(asServicename, parent, asCliPath)
+{
+
+}
+
+/// Send a response to the client.
+/// @details Performed on the service side.
+/// @param arg1...arg10 Parameters.
+/// @return Reply to client.
+QVariant DapGetListWalletsCommand::respondToClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3,
+ const QVariant &arg4, const QVariant &arg5, const QVariant &arg6,
+ const QVariant &arg7, const QVariant &arg8, const QVariant &arg9,
+ const QVariant &arg10)
+{
+ Q_UNUSED(arg1)
+ Q_UNUSED(arg2)
+ Q_UNUSED(arg3)
+ Q_UNUSED(arg4)
+ Q_UNUSED(arg5)
+ Q_UNUSED(arg6)
+ Q_UNUSED(arg7)
+ Q_UNUSED(arg8)
+ Q_UNUSED(arg9)
+ Q_UNUSED(arg10)
+
+ QStringList wallets;
+
+ QProcess process;
+ process.start(QString("%1 wallet list").arg(m_sCliPath));
+ process.waitForFinished(-1);
+ QString resources = QString::fromLocal8Bit(process.readAll());
+ QRegularExpression rx("wallet:\\s(.+)\\s", QRegularExpression::MultilineOption);
+ QRegularExpressionMatchIterator itr = rx.globalMatch(resources);
+ while (itr.hasNext())
+ {
+ QRegularExpressionMatch match = itr.next();
+ wallets.append(match.captured(1));
+ }
+
+ return wallets;
+}
diff --git a/handlers/DapGetListWalletsCommand.h b/handlers/DapGetListWalletsCommand.h
new file mode 100644
index 00000000..9805de41
--- /dev/null
+++ b/handlers/DapGetListWalletsCommand.h
@@ -0,0 +1,34 @@
+#ifndef DAPGETLISTWALLETSCOMMAND_H
+#define DAPGETLISTWALLETSCOMMAND_H
+
+#include <QProcess>
+#include <QRegExp>
+#include <QRegularExpression>
+#include <QByteArray>
+
+#include "DapWallet.h"
+#include "DapAbstractCommand.h"
+
+class DapGetListWalletsCommand : public DapAbstractCommand
+{
+public:
+ /// Overloaded constructor.
+ /// @param asServiceName Service name.
+ /// @param parent Parent.
+ /// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+ /// @param asCliPath The path to cli nodes.
+ DapGetListWalletsCommand(const QString &asServicename, QObject *parent = nullptr, const QString &asCliPath = QString());
+
+public slots:
+ /// Send a response to the client.
+ /// @details Performed on the service side.
+ /// @param arg1...arg10 Parameters.
+ /// @return Reply to client.
+ QVariant respondToClient(const QVariant &arg1 = QVariant(), const QVariant &arg2 = QVariant(),
+ const QVariant &arg3 = QVariant(), const QVariant &arg4 = QVariant(),
+ const QVariant &arg5 = QVariant(), const QVariant &arg6 = QVariant(),
+ const QVariant &arg7 = QVariant(), const QVariant &arg8 = QVariant(),
+ const QVariant &arg9 = QVariant(), const QVariant &arg10 = QVariant()) override;
+};
+
+#endif // DAPGETLISTWALLETSCOMMAND_H
diff --git a/handlers/DapGetWalletAddressesCommand.cpp b/handlers/DapGetWalletAddressesCommand.cpp
new file mode 100644
index 00000000..cc42b0be
--- /dev/null
+++ b/handlers/DapGetWalletAddressesCommand.cpp
@@ -0,0 +1,68 @@
+#include "DapGetWalletAddressesCommand.h"
+
+/// Overloaded constructor.
+/// @param asServiceName Service name.
+/// @param parent Parent.
+/// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+DapGetWalletAddressesCommand::DapGetWalletAddressesCommand(const QString &asServicename, QObject *parent)
+ : DapAbstractCommand(asServicename, parent)
+{
+
+}
+
+/// Send request to service.
+/// @details Performed on the client side.
+/// @param arg1...arg10 Parameters.
+void DapGetWalletAddressesCommand::requestToService(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3,
+ const QVariant &arg4, const QVariant &arg5,
+ const QVariant &arg6, const QVariant &arg7,
+ const QVariant &arg8, const QVariant &arg9,
+ const QVariant &arg10)
+{
+
+ DapAbstractCommand::requestToService(arg1, arg2.toStringList(), arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+}
+
+/// Send a response to the client.
+/// @details Performed on the service side.
+/// @param arg1...arg10 Parameters.
+/// @return Reply to client.
+QVariant DapGetWalletAddressesCommand::respondToClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3, const QVariant &arg4, const QVariant &arg5, const QVariant &arg6, const QVariant &arg7, const QVariant &arg8, const QVariant &arg9, const QVariant &arg10)
+{
+ Q_UNUSED(arg2)
+ Q_UNUSED(arg3)
+ Q_UNUSED(arg4)
+ Q_UNUSED(arg5)
+ Q_UNUSED(arg6)
+ Q_UNUSED(arg7)
+ Q_UNUSED(arg8)
+ Q_UNUSED(arg9)
+ Q_UNUSED(arg10)
+
+ QStringList walletAddress;
+ QStringList networkList = arg2.toStringList();
+ if(!networkList.isEmpty())
+ {
+ for(int i{0}; i < networkList.count(); ++i)
+ {
+ QProcess process;
+ process.start(QString("%1 wallet info -w %2 -net %3").arg(CLI_PATH).arg(arg1.toString()).arg(networkList[i]));
+ process.waitForFinished(-1);
+ QByteArray result = process.readAll();
+ QRegExp regex("wallet: (.+)\\s+addr:\\s+(.+)\\s+(balance)|(\\d+.\\d+)\\s\\((\\d+)\\)\\s(\\w+)");
+
+ int pos = 0;
+ while((pos = regex.indexIn(result, pos)) != -1)
+ {
+ if(!regex.cap(2).isEmpty())
+ {
+ walletAddress.append(networkList[i]);
+ walletAddress.append(regex.cap(2));
+ }
+ pos += regex.matchedLength();
+ }
+ }
+ }
+
+ return walletAddress;
+}
diff --git a/handlers/DapGetWalletAddressesCommand.h b/handlers/DapGetWalletAddressesCommand.h
new file mode 100644
index 00000000..adb8541f
--- /dev/null
+++ b/handlers/DapGetWalletAddressesCommand.h
@@ -0,0 +1,38 @@
+#ifndef DAPGETWALLETADDRESSESCOMMAND_H
+#define DAPGETWALLETADDRESSESCOMMAND_H
+
+#include <QProcess>
+
+#include "DapAbstractCommand.h"
+
+class DapGetWalletAddressesCommand : public DapAbstractCommand
+{
+public:
+ /// Overloaded constructor.
+ /// @param asServiceName Service name.
+ /// @param parent Parent.
+ /// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+ DapGetWalletAddressesCommand(const QString &asServicename, QObject *parent = nullptr);
+
+public slots:
+ /// Send request to service.
+ /// @details Performed on the client side.
+ /// @param arg1...arg10 Parameters.
+ Q_INVOKABLE virtual void requestToService(const QVariant &arg1 = QVariant(),
+ const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
+ const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
+ const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
+ const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
+ const QVariant &arg10 = QVariant()) override;
+ /// Send a response to the client.
+ /// @details Performed on the service side.
+ /// @param arg1...arg10 Parameters.
+ /// @return Reply to client.
+ QVariant respondToClient(const QVariant &arg1 = QVariant(), const QVariant &arg2 = QVariant(),
+ const QVariant &arg3 = QVariant(), const QVariant &arg4 = QVariant(),
+ const QVariant &arg5 = QVariant(), const QVariant &arg6 = QVariant(),
+ const QVariant &arg7 = QVariant(), const QVariant &arg8 = QVariant(),
+ const QVariant &arg9 = QVariant(), const QVariant &arg10 = QVariant()) override;
+};
+
+#endif // DAPGETWALLETADDRESSESCOMMAND_H
diff --git a/handlers/DapGetWalletHistoryCommand.cpp b/handlers/DapGetWalletHistoryCommand.cpp
new file mode 100644
index 00000000..5007026c
--- /dev/null
+++ b/handlers/DapGetWalletHistoryCommand.cpp
@@ -0,0 +1,63 @@
+#include "DapGetWalletHistoryCommand.h"
+
+/// Overloaded constructor.
+/// @param asServiceName Service name.
+/// @param parent Parent.
+/// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+/// @param asCliPath The path to cli nodes.
+DapGetWalletHistoryCommand::DapGetWalletHistoryCommand(const QString &asServicename, QObject *parent, const QString &asCliPath)
+ : DapAbstractCommand(asServicename, parent, asCliPath)
+{
+
+}
+
+/// Send a response to the client.
+/// @details Performed on the service side.
+/// @param arg1 Network.
+/// @param arg2 Chain.
+/// @param arg3 Wallet address.
+/// @param arg4...arg10 Parameters.
+/// @return Reply to client.
+QVariant DapGetWalletHistoryCommand::respondToClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3, const QVariant &arg4, const QVariant &arg5, const QVariant &arg6, const QVariant &arg7, const QVariant &arg8, const QVariant &arg9, const QVariant &arg10)
+{
+ Q_UNUSED(arg1)
+ Q_UNUSED(arg2)
+ Q_UNUSED(arg3)
+ Q_UNUSED(arg4)
+ Q_UNUSED(arg5)
+ Q_UNUSED(arg6)
+ Q_UNUSED(arg7)
+ Q_UNUSED(arg8)
+ Q_UNUSED(arg9)
+ Q_UNUSED(arg10)
+
+ QList<DapWalletHistoryEvent> events;
+ QProcess process;
+ process.start(QString("%1 tx_history -net %2 -chain %3 -addr %4").arg(m_sCliPath).arg(arg1.toString()).arg(arg2.toString()).arg(arg3.toString()));
+ process.waitForFinished(-1);
+ QByteArray result = process.readAll();
+ if(!result.isEmpty())
+ {
+ QRegularExpression regular("((\\w{3}\\s+){2}\\d{1,2}\\s+(\\d{1,2}:*){3}\\s+\\d{4})\\s+(\\w+)\\s+(\\d+)\\s(\\w+)\\s+\\w+\\s+([\\w\\d]+)", QRegularExpression::MultilineOption);
+ QRegularExpressionMatchIterator matchItr = regular.globalMatch(result);
+
+ while (matchItr.hasNext())
+ {
+ DapWalletHistoryEvent event;
+ QRegularExpressionMatch match = matchItr.next();
+ QLocale setLocale = QLocale(QLocale::English, QLocale::UnitedStates);
+ event.setDate(setLocale.toDateTime(match.captured(1), "ddd MMM d hh:mm:ss yyyy").toString("yyyy-MM-dd"));
+ event.setStatus(match.captured(4) == "send" ? "Sent" : "Received");
+ event.setAmount(match.captured(5).toDouble());
+ event.setName(match.captured(6));
+ event.setWallet(arg4.toString());
+ events.append(event);
+ }
+ }
+
+ QByteArray datas;
+ QDataStream out(&datas, QIODevice::WriteOnly);
+ out << events;
+
+ return QJsonValue::fromVariant(datas.toHex());;
+}
diff --git a/handlers/DapGetWalletHistoryCommand.h b/handlers/DapGetWalletHistoryCommand.h
new file mode 100644
index 00000000..cbd1b298
--- /dev/null
+++ b/handlers/DapGetWalletHistoryCommand.h
@@ -0,0 +1,38 @@
+#ifndef DAPGETWALLETHISTORYCOMMAND_H
+#define DAPGETWALLETHISTORYCOMMAND_H
+
+#include <QProcess>
+#include <QRegExp>
+#include <QRegularExpression>
+#include <QDate>
+
+#include "DapWallet.h"
+#include "DapWalletHistoryEvent.h"
+#include "DapAbstractCommand.h"
+
+class DapGetWalletHistoryCommand : public DapAbstractCommand
+{
+public:
+ /// Overloaded constructor.
+ /// @param asServiceName Service name.
+ /// @param parent Parent.
+ /// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+ /// @param asCliPath The path to cli nodes.
+ DapGetWalletHistoryCommand(const QString &asServicename, QObject *parent = nullptr, const QString &asCliPath = QString());
+
+public slots:
+ /// Send a response to the client.
+ /// @details Performed on the service side.
+ /// @param arg1 Network.
+ /// @param arg2 Chain.
+ /// @param arg3 Wallet address.
+ /// @param arg4...arg10 Parameters.
+ /// @return Reply to client.
+ QVariant respondToClient(const QVariant &arg1 = QVariant(), const QVariant &arg2 = QVariant(),
+ const QVariant &arg3 = QVariant(), const QVariant &arg4 = QVariant(),
+ const QVariant &arg5 = QVariant(), const QVariant &arg6 = QVariant(),
+ const QVariant &arg7 = QVariant(), const QVariant &arg8 = QVariant(),
+ const QVariant &arg9 = QVariant(), const QVariant &arg10 = QVariant()) override;
+};
+
+#endif // DAPGETWALLETHISTORYCOMMAND_H
diff --git a/handlers/DapGetWalletInfoCommand.cpp b/handlers/DapGetWalletInfoCommand.cpp
new file mode 100644
index 00000000..689a0bce
--- /dev/null
+++ b/handlers/DapGetWalletInfoCommand.cpp
@@ -0,0 +1,107 @@
+#include "DapGetWalletInfoCommand.h"
+
+/// Overloaded constructor.
+/// @param asServiceName Service name.
+/// @param parent Parent.
+/// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+/// @param asCliPath The path to cli nodes.
+DapGetWalletInfoCommand::DapGetWalletInfoCommand(const QString &asServicename, QObject *parent, const QString &asCliPath)
+ : DapAbstractCommand(asServicename, parent, asCliPath)
+{
+
+}
+
+/// Send a response to the client.
+/// @details Performed on the service side.
+/// @param arg1...arg10 Parameters.
+/// @return Reply to client.
+QVariant DapGetWalletInfoCommand::respondToClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3,
+ const QVariant &arg4, const QVariant &arg5, const QVariant &arg6,
+ const QVariant &arg7, const QVariant &arg8, const QVariant &arg9,
+ const QVariant &arg10)
+{
+ Q_UNUSED(arg1)
+ Q_UNUSED(arg2)
+ Q_UNUSED(arg3)
+ Q_UNUSED(arg4)
+ Q_UNUSED(arg5)
+ Q_UNUSED(arg6)
+ Q_UNUSED(arg7)
+ Q_UNUSED(arg8)
+ Q_UNUSED(arg9)
+ Q_UNUSED(arg10)
+
+ QStringList list;
+ QProcess processGetNetworks;
+ processGetNetworks.start(QString("%1 net list").arg(m_sCliPath));
+ processGetNetworks.waitForFinished(-1);
+ QString result = QString::fromLatin1(processGetNetworks.readAll());
+ result.remove(' ');
+ if(!(result.isEmpty() || result.isNull() || result.contains('\'')))
+ {
+ list = result.remove("\n").remove("\r").split(":").at(1).split(",");
+ }
+
+ DapWallet wallet;
+ wallet.setName(arg1.toString());
+ auto begin = list.begin();
+ auto end = list.end();
+ for(; begin != end; ++begin)
+ {
+
+ wallet.addNetwork(*begin);
+
+ QProcess processGetTokkens;
+ processGetTokkens.start(QString("%1 wallet info -w %2 -net %3")
+ .arg(m_sCliPath)
+ .arg(wallet.getName())
+ .arg(*begin));
+
+ processGetTokkens.waitForFinished(-1);
+ QByteArray result_tokens = processGetTokkens.readAll();
+ QRegExp regex("wallet: (.+)\\s+addr:\\s+(.+)\\s+(balance)|(\\d+.\\d+)\\s\\((\\d+)\\)\\s(\\w+)");
+
+ int pos = 0;
+ DapWalletToken *token {nullptr};
+ while((pos = regex.indexIn(result_tokens, pos)) != -1)
+ {
+
+ if(!regex.cap(2).isEmpty())
+ {
+ wallet.addAddress(regex.cap(2), *begin);
+ }
+ else
+ {
+ token = new DapWalletToken();
+ token->setName(regex.cap(6).trimmed());
+ token->setBalance(regex.cap(4).toDouble());
+ QString str = regex.cap(5);
+ token->setEmission(regex.cap(5).toULongLong());
+ token->setNetwork(*begin);
+ wallet.addToken(token);
+ }
+
+ pos += regex.matchedLength();
+ }
+ }
+
+ QByteArray datas;
+ QDataStream out(&datas, QIODevice::WriteOnly);
+ out << wallet;
+
+ return QJsonValue::fromVariant(datas.toHex());
+}
+
+
+/// Reply from service.
+/// @details Performed on the service side.
+/// @return Service reply.
+QVariant DapGetWalletInfoCommand::replyFromService()
+{
+ DapRpcServiceReply *reply = static_cast<DapRpcServiceReply *>(sender());
+
+ emit serviceResponded(reply->response().toJsonValue().toVariant().toByteArray());
+
+ return reply->response().toJsonValue().toVariant();
+}
+
diff --git a/handlers/DapGetWalletInfoCommand.h b/handlers/DapGetWalletInfoCommand.h
new file mode 100644
index 00000000..d92f5a09
--- /dev/null
+++ b/handlers/DapGetWalletInfoCommand.h
@@ -0,0 +1,37 @@
+#ifndef DAPGETWALLETINFOCOMMAND_H
+#define DAPGETWALLETINFOCOMMAND_H
+
+#include <QProcess>
+#include <QRegExp>
+#include <QRegularExpression>
+#include <QByteArray>
+#include <QDataStream>
+#include <QBuffer>
+#include <QTextCodec>
+
+#include "DapWallet.h"
+#include "DapAbstractCommand.h"
+
+class DapGetWalletInfoCommand : public DapAbstractCommand
+{
+public:
+ /// Overloaded constructor.
+ /// @param asServiceName Service name.
+ /// @param parent Parent.
+ /// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+ /// @param asCliPath The path to cli nodes.
+ DapGetWalletInfoCommand(const QString &asServicename, QObject *parent = nullptr, const QString &asCliPath = QString());
+public slots:
+ /// Send a response to the client.
+ /// @details Performed on the service side.
+ /// @param arg1...arg10 Parameters.
+ /// @return Reply to client.
+ QVariant respondToClient(const QVariant &arg1 = QVariant(), const QVariant &arg2 = QVariant(),
+ const QVariant &arg3 = QVariant(), const QVariant &arg4 = QVariant(),
+ const QVariant &arg5 = QVariant(), const QVariant &arg6 = QVariant(),
+ const QVariant &arg7 = QVariant(), const QVariant &arg8 = QVariant(),
+ const QVariant &arg9 = QVariant(), const QVariant &arg10 = QVariant()) override;
+ QVariant replyFromService() override;
+};
+
+#endif // DAPGETWALLETINFOCOMMAND_H
diff --git a/handlers/DapGetWalletTokenInfoCommand.cpp b/handlers/DapGetWalletTokenInfoCommand.cpp
new file mode 100644
index 00000000..276ce004
--- /dev/null
+++ b/handlers/DapGetWalletTokenInfoCommand.cpp
@@ -0,0 +1,53 @@
+#include "DapGetWalletTokenInfoCommand.h"
+
+/// Overloaded constructor.
+/// @param asServiceName Service name.
+/// @param parent Parent.
+/// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+DapGetWalletTokenInfoCommand::DapGetWalletTokenInfoCommand(const QString &asServicename, QObject *parent)
+ : DapAbstractCommand(asServicename, parent)
+{
+
+}
+
+/// Send a response to the client.
+/// @details Performed on the service side.
+/// @param arg1...arg10 Parameters.
+/// @return Reply to client.
+QVariant DapGetWalletTokenInfoCommand::respondToClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3, const QVariant &arg4, const QVariant &arg5, const QVariant &arg6, const QVariant &arg7, const QVariant &arg8, const QVariant &arg9, const QVariant &arg10)
+{
+ Q_UNUSED(arg2)
+ Q_UNUSED(arg3)
+ Q_UNUSED(arg4)
+ Q_UNUSED(arg5)
+ Q_UNUSED(arg6)
+ Q_UNUSED(arg7)
+ Q_UNUSED(arg8)
+ Q_UNUSED(arg9)
+ Q_UNUSED(arg10)
+
+ QStringList token;
+ if(!(arg1.toString().isEmpty() || arg1.toString().isNull()
+ || arg2.toString().isEmpty() || arg2.toString().isNull()))
+ {
+ QProcess process;
+ process.start(QString("%1 wallet info -w %2 -net %3").arg(CLI_PATH).arg(arg1.toString()).arg(arg2.toString()));
+ process.waitForFinished(-1);
+ QByteArray result = process.readAll();
+ QRegExp regex("wallet: (.+)\\s+addr:\\s+(.+)\\s+(balance)|(\\d+.\\d+)\\s\\((\\d+)\\)\\s(\\w+)");
+
+ int pos = 0;
+ while((pos = regex.indexIn(result, pos)) != -1)
+ {
+ if(regex.cap(2).isEmpty())
+ {
+ token.append(regex.cap(6));
+ token.append(regex.cap(4));
+ token.append(regex.cap(5));
+ }
+ pos += regex.matchedLength();
+ }
+ }
+
+ return token;
+}
diff --git a/handlers/DapGetWalletTokenInfoCommand.h b/handlers/DapGetWalletTokenInfoCommand.h
new file mode 100644
index 00000000..2ceaf209
--- /dev/null
+++ b/handlers/DapGetWalletTokenInfoCommand.h
@@ -0,0 +1,30 @@
+#ifndef DAPGETWALLETTOKENINFOCOMMAND_H
+#define DAPGETWALLETTOKENINFOCOMMAND_H
+
+#include <QProcess>
+#include <QRegExp>
+
+#include "DapAbstractCommand.h"
+
+class DapGetWalletTokenInfoCommand : public DapAbstractCommand
+{
+public:
+ /// Overloaded constructor.
+ /// @param asServiceName Service name.
+ /// @param parent Parent.
+ /// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+ DapGetWalletTokenInfoCommand(const QString &asServicename, QObject *parent = nullptr);
+
+public slots:
+ /// Send a response to the client.
+ /// @details Performed on the service side.
+ /// @param arg1...arg10 Parameters.
+ /// @return Reply to client.
+ QVariant respondToClient(const QVariant &arg1 = QVariant(), const QVariant &arg2 = QVariant(),
+ const QVariant &arg3 = QVariant(), const QVariant &arg4 = QVariant(),
+ const QVariant &arg5 = QVariant(), const QVariant &arg6 = QVariant(),
+ const QVariant &arg7 = QVariant(), const QVariant &arg8 = QVariant(),
+ const QVariant &arg9 = QVariant(), const QVariant &arg10 = QVariant()) override;
+};
+
+#endif // DAPGETWALLETTOKENINFOCOMMAND_H
diff --git a/handlers/DapGetWalletsInfoCommand.cpp b/handlers/DapGetWalletsInfoCommand.cpp
new file mode 100644
index 00000000..2b548e7c
--- /dev/null
+++ b/handlers/DapGetWalletsInfoCommand.cpp
@@ -0,0 +1,121 @@
+#include "DapGetWalletsInfoCommand.h"
+
+/// Overloaded constructor.
+/// @param asServiceName Service name.
+/// @param parent Parent.
+/// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+/// @param asCliPath The path to cli nodes.
+DapGetWalletsInfoCommand::DapGetWalletsInfoCommand(const QString &asServicename, QObject *parent, const QString &asCliPath)
+ : DapAbstractCommand(asServicename, parent, asCliPath)
+{
+
+}
+
+/// Send a response to the client.
+/// @details Performed on the service side.
+/// @param arg1...arg10 Parameters.
+/// @return Reply to client.
+QVariant DapGetWalletsInfoCommand::respondToClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3,
+ const QVariant &arg4, const QVariant &arg5, const QVariant &arg6,
+ const QVariant &arg7, const QVariant &arg8, const QVariant &arg9,
+ const QVariant &arg10)
+{
+ Q_UNUSED(arg1)
+ Q_UNUSED(arg2)
+ Q_UNUSED(arg3)
+ Q_UNUSED(arg4)
+ Q_UNUSED(arg5)
+ Q_UNUSED(arg6)
+ Q_UNUSED(arg7)
+ Q_UNUSED(arg8)
+ Q_UNUSED(arg9)
+ Q_UNUSED(arg10)
+
+ QList<DapWallet> wallets;
+
+ QStringList list;
+ QProcess processN;
+ processN.start(QString("%1 net list").arg(m_sCliPath));
+ processN.waitForFinished(-1);
+ QString result = QString::fromLatin1(processN.readAll());
+ result.remove(' ');
+ if(!(result.isEmpty() || result.isNull() || result.contains('\'')))
+ {
+ list = result.remove("\n").remove("\r").split(":").at(1).split(",");
+ }
+
+ QProcess process;
+ process.start(QString("%1 wallet list").arg(m_sCliPath));
+ process.waitForFinished(-1);
+ QString res = QString::fromLocal8Bit(process.readAll());
+ QRegularExpression rx("wallet:\\s(.+)\\s", QRegularExpression::MultilineOption);
+ QRegularExpressionMatchIterator itr = rx.globalMatch(res);
+ while (itr.hasNext())
+ {
+ QRegularExpressionMatch match = itr.next();
+ QString walletName = match.captured(1);
+ DapWallet wallet;
+ wallet.setName(walletName);
+ auto begin = list.begin();
+ auto end = list.end();
+ for(; begin != end; ++begin)
+ {
+
+ wallet.addNetwork(*begin);
+
+ QProcess process_token;
+ process_token.start(QString("%1 wallet info -w %2 -net %3")
+ .arg(m_sCliPath)
+ .arg(walletName)
+ .arg(*begin));
+
+ process_token.waitForFinished(-1);
+ QByteArray result_tokens = process_token.readAll();
+ QRegExp regex("wallet: (.+)\\s+addr:\\s+(.+)\\s+(balance)|(\\d+.\\d+)\\s\\((\\d+)\\)\\s(\\w+)");
+
+ int pos = 0;
+ DapWalletToken *token {nullptr};
+ while((pos = regex.indexIn(result_tokens, pos)) != -1)
+ {
+
+ if(!regex.cap(2).isEmpty())
+ {
+ wallet.addAddress(regex.cap(2), *begin);
+ }
+ else
+ {
+ token = new DapWalletToken();
+ token->setName(regex.cap(6).trimmed());
+ token->setBalance(regex.cap(4).toDouble());
+ QString str = regex.cap(5);
+ token->setEmission(regex.cap(5).toULongLong());
+ token->setNetwork(*begin);
+ wallet.addToken(token);
+ }
+
+ pos += regex.matchedLength();
+ }
+
+ }
+ wallets.append(wallet);
+ }
+
+ QByteArray datas;
+ QDataStream out(&datas, QIODevice::WriteOnly);
+ out << wallets;
+
+ return QJsonValue::fromVariant(datas.toHex());
+}
+
+
+/// Reply from service.
+/// @details Performed on the service side.
+/// @return Service reply.
+QVariant DapGetWalletsInfoCommand::replyFromService()
+{
+ DapRpcServiceReply *reply = static_cast<DapRpcServiceReply *>(sender());
+
+ emit serviceResponded(reply->response().toJsonValue().toVariant().toByteArray());
+
+ return reply->response().toJsonValue().toVariant();
+}
diff --git a/handlers/DapGetWalletsInfoCommand.h b/handlers/DapGetWalletsInfoCommand.h
new file mode 100644
index 00000000..75cdd974
--- /dev/null
+++ b/handlers/DapGetWalletsInfoCommand.h
@@ -0,0 +1,38 @@
+#ifndef DAPGETWALLETSINFOCOMMAND_H
+#define DAPGETWALLETSINFOCOMMAND_H
+
+#include <QProcess>
+#include <QRegExp>
+#include <QRegularExpression>
+#include <QByteArray>
+#include <QDataStream>
+#include <QBuffer>
+#include <QTextCodec>
+
+#include "DapWallet.h"
+#include "DapAbstractCommand.h"
+
+class DapGetWalletsInfoCommand : public DapAbstractCommand
+{
+public:
+ /// Overloaded constructor.
+ /// @param asServiceName Service name.
+ /// @param parent Parent.
+ /// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+ /// @param asCliPath The path to cli nodes.
+ DapGetWalletsInfoCommand(const QString &asServicename, QObject *parent = nullptr, const QString &asCliPath = QString());
+
+public slots:
+ /// Send a response to the client.
+ /// @details Performed on the service side.
+ /// @param arg1...arg10 Parameters.
+ /// @return Reply to client.
+ QVariant respondToClient(const QVariant &arg1 = QVariant(), const QVariant &arg2 = QVariant(),
+ const QVariant &arg3 = QVariant(), const QVariant &arg4 = QVariant(),
+ const QVariant &arg5 = QVariant(), const QVariant &arg6 = QVariant(),
+ const QVariant &arg7 = QVariant(), const QVariant &arg8 = QVariant(),
+ const QVariant &arg9 = QVariant(), const QVariant &arg10 = QVariant()) override;
+ QVariant replyFromService() override;
+};
+
+#endif // DAPGETWALLETSINFOCOMMAND_H
diff --git a/handlers/DapMempoolProcessCommand.cpp b/handlers/DapMempoolProcessCommand.cpp
new file mode 100644
index 00000000..5f08999f
--- /dev/null
+++ b/handlers/DapMempoolProcessCommand.cpp
@@ -0,0 +1,43 @@
+#include "DapMempoolProcessCommand.h"
+
+/// Overloaded constructor.
+/// @param asServiceName Service name.
+/// @param parent Parent.
+/// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+/// @param asCliPath The path to cli nodes.
+DapMempoolProcessCommand::DapMempoolProcessCommand(const QString &asServicename, QObject *parent, const QString &asCliPath)
+ : DapAbstractCommand(asServicename, parent, asCliPath)
+{
+
+}
+
+/// Send a response to the client.
+/// @details Performed on the service side.
+/// @param arg1 Network.
+/// @param arg2 Chain.
+/// @param arg3...arg10 Parameters.
+/// @return Reply to client.
+QVariant DapMempoolProcessCommand::respondToClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3, const QVariant &arg4, const QVariant &arg5, const QVariant &arg6, const QVariant &arg7, const QVariant &arg8, const QVariant &arg9, const QVariant &arg10)
+{
+ Q_UNUSED(arg1)
+ Q_UNUSED(arg2)
+ Q_UNUSED(arg3)
+ Q_UNUSED(arg4)
+ Q_UNUSED(arg5)
+ Q_UNUSED(arg6)
+ Q_UNUSED(arg7)
+ Q_UNUSED(arg8)
+ Q_UNUSED(arg9)
+ Q_UNUSED(arg10)
+
+ QProcess process;
+ process.start(QString("%1 mempool_proc -net %2 -chain %3").arg(m_sCliPath).arg(arg1.toString()).arg(arg2.toString()));
+ process.waitForFinished(-1);
+ process.readAll();
+ QString result = QString::fromLatin1(process.readAll());
+ if(result.isEmpty() || result.isNull() || result.contains("No records in mempool") )
+ {
+ return false;
+ }
+ return true;
+}
diff --git a/handlers/DapMempoolProcessCommand.h b/handlers/DapMempoolProcessCommand.h
new file mode 100644
index 00000000..3947203c
--- /dev/null
+++ b/handlers/DapMempoolProcessCommand.h
@@ -0,0 +1,32 @@
+#ifndef DAPMEMPOOLPROCESSCOMMAND_H
+#define DAPMEMPOOLPROCESSCOMMAND_H
+
+#include <QProcess>
+
+#include "DapAbstractCommand.h"
+
+class DapMempoolProcessCommand : public DapAbstractCommand
+{
+public:
+ /// Overloaded constructor.
+ /// @param asServiceName Service name.
+ /// @param parent Parent.
+ /// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+ /// @param asCliPath The path to cli nodes.
+ DapMempoolProcessCommand(const QString &asServicename, QObject *parent = nullptr, const QString &asCliPath = QString());
+
+public slots:
+ /// Send a response to the client.
+ /// @details Performed on the service side.
+ /// @param arg1 Network.
+ /// @param arg2 Chain.
+ /// @param arg3...arg10 Parameters.
+ /// @return Reply to client.
+ QVariant respondToClient(const QVariant &arg1 = QVariant(), const QVariant &arg2 = QVariant(),
+ const QVariant &arg3 = QVariant(), const QVariant &arg4 = QVariant(),
+ const QVariant &arg5 = QVariant(), const QVariant &arg6 = QVariant(),
+ const QVariant &arg7 = QVariant(), const QVariant &arg8 = QVariant(),
+ const QVariant &arg9 = QVariant(), const QVariant &arg10 = QVariant()) override;
+};
+
+#endif // DAPMEMPOOLPROCESSCOMMAND_H
diff --git a/handlers/DapQuitApplicationCommand.cpp b/handlers/DapQuitApplicationCommand.cpp
new file mode 100644
index 00000000..c5147bd5
--- /dev/null
+++ b/handlers/DapQuitApplicationCommand.cpp
@@ -0,0 +1,50 @@
+#include "DapQuitApplicationCommand.h"
+
+/// Overloaded constructor.
+/// @param asServiceName Service name.
+/// @param parent Parent.
+/// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+DapQuitApplicationCommand::DapQuitApplicationCommand(const QString &asServicename, QObject *parent)
+ : DapAbstractCommand(asServicename, parent)
+{
+
+}
+
+/// Send a notification to the client. At the same time, you should not expect a response from the client.
+/// @details Performed on the service side.
+/// @param arg1...arg10 Parameters.
+void DapQuitApplicationCommand::notifyToClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3,
+ const QVariant &arg4, const QVariant &arg5, const QVariant &arg6,
+ const QVariant &arg7, const QVariant &arg8, const QVariant &arg9,
+ const QVariant &arg10)
+{
+ DapAbstractCommand::notifyToClient(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+
+ DapRpcLocalServer * server = dynamic_cast<DapRpcLocalServer *>(m_parent);
+
+ Q_ASSERT(server);
+
+ connect(server, SIGNAL(onClientDisconnected()), qApp, SLOT(quit()));
+}
+
+/// Process the notification from the service on the client side.
+/// @details Performed on the client side.
+/// @param arg1...arg10 Parameters.
+void DapQuitApplicationCommand::notifedFromService(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3,
+ const QVariant &arg4, const QVariant &arg5, const QVariant &arg6,
+ const QVariant &arg7, const QVariant &arg8, const QVariant &arg9,
+ const QVariant &arg10)
+{
+ Q_UNUSED(arg1);
+ Q_UNUSED(arg2);
+ Q_UNUSED(arg3);
+ Q_UNUSED(arg4);
+ Q_UNUSED(arg5);
+ Q_UNUSED(arg6);
+ Q_UNUSED(arg7);
+ Q_UNUSED(arg8);
+ Q_UNUSED(arg9);
+ Q_UNUSED(arg10);
+
+ qApp->quit();
+}
diff --git a/handlers/DapQuitApplicationCommand.h b/handlers/DapQuitApplicationCommand.h
new file mode 100644
index 00000000..3eaa3a80
--- /dev/null
+++ b/handlers/DapQuitApplicationCommand.h
@@ -0,0 +1,50 @@
+/****************************************************************************
+**
+** This file is part of the libdap-qt-ui-chain-wallet library.
+**
+** The class implements the exit command of the application. Both the
+** GUI client and the service complete the work.
+**
+****************************************************************************/
+
+#ifndef DAPQUITAPPLICATIONCOMMAND_H
+#define DAPQUITAPPLICATIONCOMMAND_H
+
+#include <QObject>
+#include <QCoreApplication>
+
+#include "DapAbstractCommand.h"
+
+class DapQuitApplicationCommand : public DapAbstractCommand
+{
+ Q_OBJECT
+
+public:
+ /// Overloaded constructor.
+ /// @param asServiceName Service name.
+ /// @param parent Parent.
+ /// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+ explicit DapQuitApplicationCommand(const QString &asServicename, QObject *parent = nullptr);
+
+public slots:
+ /// Send a notification to the client. At the same time, you should not expect a response from the client.
+ /// @details Performed on the service side.
+ /// @param arg1...arg10 Parameters.
+ Q_INVOKABLE virtual void notifyToClient(const QVariant &arg1 = QVariant(),
+ const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
+ const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
+ const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
+ const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
+ const QVariant &arg10 = QVariant()) override;
+ /// Process the notification from the service on the client side.
+ /// @details Performed on the client side.
+ /// @param arg1...arg10 Parameters.
+ Q_INVOKABLE virtual void notifedFromService(const QVariant &arg1 = QVariant(),
+ const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
+ const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
+ const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
+ const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
+ const QVariant &arg10 = QVariant()) override;
+};
+
+#endif // DAPQUITAPPLICATIONCOMMAND_H
diff --git a/handlers/DapRunCmdCommand.cpp b/handlers/DapRunCmdCommand.cpp
new file mode 100644
index 00000000..0960e470
--- /dev/null
+++ b/handlers/DapRunCmdCommand.cpp
@@ -0,0 +1,42 @@
+#include "DapRunCmdCommand.h"
+
+/// Overloaded constructor.
+/// @param asServiceName Service name.
+/// @param parent Parent.
+/// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+/// @param asCliPath The path to cli nodes.
+DapRunCmdCommand::DapRunCmdCommand(const QString &asServicename, QObject *parent, const QString &asCliPath)
+ : DapAbstractCommand(asServicename, parent, asCliPath)
+{
+
+}
+
+/// Send a response to the client.
+/// @details Performed on the service side.
+/// @param arg1 Command.
+/// @param arg2...arg10 Parameters.
+/// @return Reply to client.
+QVariant DapRunCmdCommand::respondToClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3, const QVariant &arg4, const QVariant &arg5, const QVariant &arg6, const QVariant &arg7, const QVariant &arg8, const QVariant &arg9, const QVariant &arg10)
+{
+ Q_UNUSED(arg1)
+ Q_UNUSED(arg2)
+ Q_UNUSED(arg3)
+ Q_UNUSED(arg4)
+ Q_UNUSED(arg5)
+ Q_UNUSED(arg6)
+ Q_UNUSED(arg7)
+ Q_UNUSED(arg8)
+ Q_UNUSED(arg9)
+ Q_UNUSED(arg10)
+
+
+ QProcess process;
+ process.start(QString("%1 %2").arg(m_sCliPath).arg(arg1.toString()));
+ process.waitForFinished(-1);
+ QString result = QString::fromLatin1(process.readAll());
+ QJsonArray response;
+ response.append(QJsonValue(arg1.toString()));
+ response.append(QJsonValue(result));
+
+ return response;
+}
diff --git a/handlers/DapRunCmdCommand.h b/handlers/DapRunCmdCommand.h
new file mode 100644
index 00000000..f224cb40
--- /dev/null
+++ b/handlers/DapRunCmdCommand.h
@@ -0,0 +1,31 @@
+#ifndef DAPRUNCMDCOMMAND_H
+#define DAPRUNCMDCOMMAND_H
+
+#include <QProcess>
+
+#include "DapAbstractCommand.h"
+
+class DapRunCmdCommand : public DapAbstractCommand
+{
+public:
+ /// Overloaded constructor.
+ /// @param asServiceName Service name.
+ /// @param parent Parent.
+ /// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+ /// @param asCliPath The path to cli nodes.
+ DapRunCmdCommand(const QString &asServicename, QObject *parent = nullptr, const QString &asCliPath = QString());
+
+public slots:
+ /// Send a response to the client.
+ /// @details Performed on the service side.
+ /// @param arg1 Command.
+ /// @param arg2...arg10 Parameters.
+ /// @return Reply to client.
+ QVariant respondToClient(const QVariant &arg1 = QVariant(), const QVariant &arg2 = QVariant(),
+ const QVariant &arg3 = QVariant(), const QVariant &arg4 = QVariant(),
+ const QVariant &arg5 = QVariant(), const QVariant &arg6 = QVariant(),
+ const QVariant &arg7 = QVariant(), const QVariant &arg8 = QVariant(),
+ const QVariant &arg9 = QVariant(), const QVariant &arg10 = QVariant()) override;
+};
+
+#endif // DAPRUNCMDCOMMAND_H
diff --git a/handlers/DapSaveHistoryExecutedCmdCommand.cpp b/handlers/DapSaveHistoryExecutedCmdCommand.cpp
new file mode 100644
index 00000000..b5e1f882
--- /dev/null
+++ b/handlers/DapSaveHistoryExecutedCmdCommand.cpp
@@ -0,0 +1,42 @@
+#include "DapSaveHistoryExecutedCmdCommand.h"
+
+/// Overloaded constructor.
+/// @param asServiceName Service name.
+/// @param parent Parent.
+/// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+/// @param asCliPath The path to history file.
+DapSaveHistoryExecutedCmdCommand::DapSaveHistoryExecutedCmdCommand(const QString &asServicename, QObject *parent, const QString &asCliPath)
+ : DapAbstractCommand(asServicename, parent, asCliPath)
+{
+ DapRpcLocalServer * server = dynamic_cast<DapRpcLocalServer *>(m_parent);
+ if(server)
+ {
+ QDir().mkpath(QFileInfo(m_sCliPath).path());
+ m_File = new QFile(m_sCliPath, this);
+ }
+}
+
+/// Process the notification from the client on the service side.
+/// @details Performed on the service side.
+/// @param arg1 Command.
+/// @param arg2...arg10 Parameters.
+void DapSaveHistoryExecutedCmdCommand::notifedFromClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3, const QVariant &arg4, const QVariant &arg5, const QVariant &arg6, const QVariant &arg7, const QVariant &arg8, const QVariant &arg9, const QVariant &arg10)
+{
+ Q_UNUSED(arg1)
+ Q_UNUSED(arg2)
+ Q_UNUSED(arg3)
+ Q_UNUSED(arg4)
+ Q_UNUSED(arg5)
+ Q_UNUSED(arg6)
+ Q_UNUSED(arg7)
+ Q_UNUSED(arg8)
+ Q_UNUSED(arg9)
+ Q_UNUSED(arg10)
+
+
+ if (!m_File->open(QIODevice::Append | QIODevice::ReadWrite))
+ return;
+
+ m_File->write(arg1.toString().toUtf8() + '\n');
+ m_File->close();
+}
diff --git a/handlers/DapSaveHistoryExecutedCmdCommand.h b/handlers/DapSaveHistoryExecutedCmdCommand.h
new file mode 100644
index 00000000..f4982309
--- /dev/null
+++ b/handlers/DapSaveHistoryExecutedCmdCommand.h
@@ -0,0 +1,34 @@
+#ifndef DAPSAVEHISTORYEXECUTEDCMDCOMMAND_H
+#define DAPSAVEHISTORYEXECUTEDCMDCOMMAND_H
+
+#include <QFile>
+#include <QDir>
+
+#include "DapAbstractCommand.h"
+
+class DapSaveHistoryExecutedCmdCommand : public DapAbstractCommand
+{
+ /// Command history file.
+ QFile * m_File{nullptr};
+
+public:
+ /// Overloaded constructor.
+ /// @param asServiceName Service name.
+ /// @param parent Parent.
+ /// @details The parent must be either DapRPCSocket or DapRPCLocalServer.
+ /// @param asCliPath The path to history file.
+ DapSaveHistoryExecutedCmdCommand(const QString &asServicename, QObject *parent = nullptr, const QString &asCliPath = QString());
+
+public slots:
+ /// Process the notification from the client on the service side.
+ /// @details Performed on the service side.
+ /// @param arg1 Command.
+ /// @param arg2...arg10 Parameters.
+ void notifedFromClient(const QVariant &arg1 = QVariant(), const QVariant &arg2 = QVariant(),
+ const QVariant &arg3 = QVariant(), const QVariant &arg4 = QVariant(),
+ const QVariant &arg5 = QVariant(), const QVariant &arg6 = QVariant(),
+ const QVariant &arg7 = QVariant(), const QVariant &arg8 = QVariant(),
+ const QVariant &arg9 = QVariant(), const QVariant &arg10 = QVariant()) override;
+};
+
+#endif // DAPSAVEHISTORYEXECUTEDCMDCOMMAND_H
diff --git a/handlers/DapUpdateLogsCommand.cpp b/handlers/DapUpdateLogsCommand.cpp
new file mode 100644
index 00000000..f04a0a43
--- /dev/null
+++ b/handlers/DapUpdateLogsCommand.cpp
@@ -0,0 +1,132 @@
+#include "DapUpdateLogsCommand.h"
+
+/// Overloaded constructor.
+/// @param asServiceName Service name.
+/// @param parent Parent.
+DapUpdateLogsCommand::DapUpdateLogsCommand(const QString &asServiceName, QObject *parent, const QString &asLogFile)
+ : DapAbstractCommand(asServiceName, parent), m_csLogFile(asLogFile)
+{
+ qInfo() << "Initialization of DapUpdateLogsCommand...";
+ DapRpcLocalServer * server = dynamic_cast<DapRpcLocalServer *>(m_parent);
+
+ // Watcher is created only on the service side
+ if(server)
+ {
+ // Initialize the watcher for the log file of the node
+ m_watcherLogFile = new QFileSystemWatcher(this);
+ QFileInfo fileInfo(m_csLogFile);
+ m_watcherLogFile->addPath(m_csLogFile);
+ m_watcherLogFile->addPath(fileInfo.absolutePath());
+
+ if (!(m_watcherLogFile->addPath(m_csLogFile) || fileInfo.exists()))
+ {
+ qWarning() << "Node log file not found";
+ }
+
+ connect(m_watcherLogFile, &QFileSystemWatcher::fileChanged, this, [&]
+ {
+ if(m_isNoifyClient)
+ {
+ readLogFile();
+ notifyToClient(m_bufLog);
+ }
+ if(!m_watcherLogFile->files().contains(m_csLogFile))
+ {
+ m_watcherLogFile->addPath(m_csLogFile);
+ }
+ });
+ // Signal-slot connection restoring control over the log file of the node
+ // if it is deleted during the operation of the service
+ connect(m_watcherLogFile, &QFileSystemWatcher::directoryChanged, this, [=]
+ {
+ qDebug() << "Log file directory changed";
+ if(!m_watcherLogFile->files().contains(m_csLogFile))
+ {
+ m_watcherLogFile->addPath(m_csLogFile);
+ }
+ });
+ }
+}
+
+/// Process the notification from the client on the service side.
+/// @details Performed on the service side.
+/// @param arg1...arg10 Parameters.
+void DapUpdateLogsCommand::notifedFromClient(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3,
+ const QVariant &arg4, const QVariant &arg5, const QVariant &arg6,
+ const QVariant &arg7, const QVariant &arg8, const QVariant &arg9,
+ const QVariant &arg10)
+{
+ Q_UNUSED(arg2)
+ Q_UNUSED(arg3)
+ Q_UNUSED(arg4)
+ Q_UNUSED(arg5)
+ Q_UNUSED(arg6)
+ Q_UNUSED(arg7)
+ Q_UNUSED(arg8)
+ Q_UNUSED(arg9)
+ Q_UNUSED(arg10)
+
+
+
+ if(arg1.toString() == "start")
+ {
+ m_isNoifyClient = true;
+ m_bufferSize = arg2.toInt();
+ readLogFile();
+ notifyToClient(m_bufLog);
+ }
+ else if(arg1.toString() == "stop")
+ {
+ m_isNoifyClient = false;
+ }
+}
+
+///The slot reads logs to the buffer.
+void DapUpdateLogsCommand::readLogFile()
+{
+ QFile dapLogFile(m_csLogFile);
+ if (!dapLogFile.open(QIODevice::ReadOnly | QIODevice::Text))
+ {
+ qWarning() << "The node log file does not open";
+ return;
+ }
+ QTextStream readFile(&dapLogFile);
+ m_bufLog.clear();
+ while(!readFile.atEnd())
+ {
+ m_bufLog.append(readFile.readLine());
+
+ if(m_bufLog.size() > m_bufferSize)
+ {
+ m_bufLog.removeFirst();
+ }
+ }
+
+ if(readFile.status()!= QTextStream::Ok)
+ {
+ qWarning() << "Error reading log file";
+ }
+ dapLogFile.close();
+}
+
+/// Process the notification from the service on the client side.
+/// @details Performed on the client side.
+/// @param arg1...arg10 Parameters.
+void DapUpdateLogsCommand::notifedFromService(const QVariant &arg1, const QVariant &arg2, const QVariant &arg3,
+ const QVariant &arg4, const QVariant &arg5, const QVariant &arg6,
+ const QVariant &arg7, const QVariant &arg8, const QVariant &arg9,
+ const QVariant &arg10)
+{
+ Q_UNUSED(arg1);
+ Q_UNUSED(arg2);
+ Q_UNUSED(arg3);
+ Q_UNUSED(arg4);
+ Q_UNUSED(arg5);
+ Q_UNUSED(arg6);
+ Q_UNUSED(arg7);
+ Q_UNUSED(arg8);
+ Q_UNUSED(arg9);
+ Q_UNUSED(arg10);
+
+ emit clientNotifed(arg1);
+}
diff --git a/handlers/DapUpdateLogsCommand.h b/handlers/DapUpdateLogsCommand.h
new file mode 100644
index 00000000..132fb797
--- /dev/null
+++ b/handlers/DapUpdateLogsCommand.h
@@ -0,0 +1,58 @@
+#ifndef DAPUPDATELOGSCOMMAND_H
+#define DAPUPDATELOGSCOMMAND_H
+
+#include <QFile>
+#include <QFileInfo>
+#include <QFileSystemWatcher>
+
+#include "DapAbstractCommand.h"
+
+#define DEFAULT_BUFFER_SIZE 20
+
+class DapUpdateLogsCommand : public DapAbstractCommand
+{
+ ///The cursor position from which to start reading the file.
+ qint64 m_seekFile {0};
+ ///The number of rows that are stored in memory.
+ int m_bufferSize {DEFAULT_BUFFER_SIZE};
+ ///The container with the lines from the log.
+ QStringList m_bufLog;
+
+ const QString m_csLogFile;
+ ///Monitors changes in the log file.
+ QFileSystemWatcher *m_watcherLogFile {nullptr};
+
+ bool m_isNoifyClient {false};
+
+public:
+ /// Overloaded constructor.
+ /// @param asServiceName Service name.
+ /// @param parent Parent.
+ explicit DapUpdateLogsCommand(const QString &asServicename, QObject *parent, const QString &asLogFile = QString());
+
+protected slots:
+ ///The slot reads logs to the buffer.
+ void readLogFile();
+
+public slots:
+ /// Process the notification from the client on the service side.
+ /// @details Performed on the service side.
+ /// @param arg1...arg10 Parameters.
+ virtual void notifedFromClient(const QVariant &arg1 = QVariant(),
+ const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
+ const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
+ const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
+ const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
+ const QVariant &arg10 = QVariant()) override;
+ /// Process the notification from the service on the client side.
+ /// @details Performed on the client side.
+ /// @param arg1...arg10 Parameters.
+ Q_INVOKABLE virtual void notifedFromService(const QVariant &arg1 = QVariant(),
+ const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
+ const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
+ const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
+ const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
+ const QVariant &arg10 = QVariant()) override;
+};
+
+#endif // DAPUPDATELOGSCOMMAND_H
diff --git a/libdap-qt-ui-chain-wallet.pri b/libdap-qt-ui-chain-wallet.pri
new file mode 100644
index 00000000..f1674f66
--- /dev/null
+++ b/libdap-qt-ui-chain-wallet.pri
@@ -0,0 +1,81 @@
+QT += core
+
+INCLUDEPATH += $$PWD $$PWD/../
+
+
+include (dapRPCProtocol/DapRPCProtocol.pri)
+
+win32{
+ QMAKE_CXXFLAGS += -mno-ms-bitfields
+}
+
+DISTFILES +=
+
+HEADERS += \
+ $$PWD/DapChainConvertor.h \
+ $$PWD/DapHistoryType.h \
+ $$PWD/DapLogMessage.h \
+ $$PWD/DapNodeType.h \
+ $$PWD/DapWallet.h \
+ $$PWD/DapWalletHistoryEvent.h \
+ $$PWD/DapWalletToken.h \
+ $$PWD/handlers/DapAbstractCommand.h \
+ $$PWD/handlers/DapActivateClientCommand.h \
+ $$PWD/handlers/DapAddWalletCommand.h \
+ $$PWD/handlers/DapCreateTransactionCommand.h \
+ $$PWD/handlers/DapExportLogCommand.h \
+ $$PWD/handlers/DapGetHistoryExecutedCmdCommand.h \
+ $$PWD/handlers/DapGetListNetworksCommand.h \
+ $$PWD/handlers/DapGetListWalletsCommand.h \
+ $$PWD/handlers/DapGetWalletsInfoCommand.h \
+ $$PWD/handlers/DapGetWalletAddressesCommand.h \
+ $$PWD/handlers/DapGetWalletHistoryCommand.h \
+ $$PWD/handlers/DapGetWalletInfoCommand.h \
+ $$PWD/handlers/DapGetWalletTokenInfoCommand.h \
+ $$PWD/handlers/DapMempoolProcessCommand.h \
+ $$PWD/handlers/DapQuitApplicationCommand.h \
+ $$PWD/handlers/DapRunCmdCommand.h \
+ $$PWD/handlers/DapSaveHistoryExecutedCmdCommand.h \
+ $$PWD/handlers/DapUpdateLogsCommand.h \
+ $$PWD/models/DapWalletModel.h \
+ $$PWD/serviceClient/DapServiceClient.h \
+ $$PWD/serviceClient/DapServiceClientNativeAbstract.h \
+ $$PWD/serviceClient/DapServiceClientNativeLinux.h \
+ $$PWD/serviceClient/DapServiceClientNativeMacOS.h \
+ $$PWD/serviceClient/DapServiceClientNativeWin.h
+
+SOURCES += \
+ $$PWD/DapChainConvertor.cpp \
+ $$PWD/DapHistoryType.cpp \
+ $$PWD/DapLogMessage.cpp \
+ $$PWD/DapWallet.cpp \
+ $$PWD/DapWalletHistoryEvent.cpp \
+ $$PWD/DapWalletToken.cpp \
+ $$PWD/handlers/DapAbstractCommand.cpp \
+ $$PWD/handlers/DapActivateClientCommand.cpp \
+ $$PWD/handlers/DapAddWalletCommand.cpp \
+ $$PWD/handlers/DapCreateTransactionCommand.cpp \
+ $$PWD/handlers/DapExportLogCommand.cpp \
+ $$PWD/handlers/DapGetHistoryExecutedCmdCommand.cpp \
+ $$PWD/handlers/DapGetListNetworksCommand.cpp \
+ $$PWD/handlers/DapGetListWalletsCommand.cpp \
+ $$PWD/handlers/DapGetWalletsInfoCommand.cpp \
+ $$PWD/handlers/DapGetWalletAddressesCommand.cpp \
+ $$PWD/handlers/DapGetWalletHistoryCommand.cpp \
+ $$PWD/handlers/DapGetWalletInfoCommand.cpp \
+ $$PWD/handlers/DapGetWalletTokenInfoCommand.cpp \
+ $$PWD/handlers/DapMempoolProcessCommand.cpp \
+ $$PWD/handlers/DapQuitApplicationCommand.cpp \
+ $$PWD/handlers/DapRunCmdCommand.cpp \
+ $$PWD/handlers/DapSaveHistoryExecutedCmdCommand.cpp \
+ $$PWD/handlers/DapUpdateLogsCommand.cpp \
+ $$PWD/models/DapWalletModel.cpp \
+ $$PWD/serviceClient/DapServiceClient.cpp \
+ $$PWD/serviceClient/DapServiceClientNativeAbstract.cpp \
+ $$PWD/serviceClient/DapServiceClientNativeLinux.cpp \
+ $$PWD/serviceClient/DapServiceClientNativeMacOS.cpp \
+ $$PWD/serviceClient/DapServiceClientNativeWin.cpp
+
+
+
+
diff --git a/models/DapWalletModel.cpp b/models/DapWalletModel.cpp
new file mode 100644
index 00000000..b794f8f0
--- /dev/null
+++ b/models/DapWalletModel.cpp
@@ -0,0 +1,129 @@
+#include "DapWalletModel.h"
+
+DapWalletModel::DapWalletModel(QObject *parent)
+ : QAbstractListModel(parent)
+{
+
+}
+
+DapWalletModel &DapWalletModel::getInstance()
+{
+ static DapWalletModel instance;
+ return instance;
+}
+
+int DapWalletModel::rowCount(const QModelIndex &parent) const
+{
+ Q_UNUSED(parent);
+
+ return m_aWallets.count();
+}
+
+QVariant DapWalletModel::data(const QModelIndex &index, int role) const
+{
+ if (!index.isValid())
+ return QVariant();
+
+ switch (role)
+ {
+ case NameDisplayRole: return m_aWallets[index.row()].getName();
+ case BalanceDisplayRole: return m_aWallets[index.row()].getBalance();
+ case AddressDisplayRole: return m_aWallets[index.row()].getAddress();
+ case IconDisplayRole: return m_aWallets[index.row()].getIcon();
+ case NetworksDisplayRole: return m_aWallets[index.row()].getNetworks();
+ case TokensDisplayRole:
+ return QVariant::fromValue<QList<QObject*>>(getTokens(index.row()));
+ case WalletsDisplayRole: return getWalletList();
+ default: break;
+ }
+
+ return QVariant();
+}
+
+QList<QObject*> DapWalletModel::getTokens(const int aIndex) const
+{
+ QList<QObject*> tokens;
+ auto cbegin = m_aWallets[aIndex].getTokens().cbegin();
+ auto cend = m_aWallets[aIndex].getTokens().cend();
+ for(; cbegin != cend; ++ cbegin)
+ tokens.append(*cbegin);
+
+ return tokens;
+}
+
+QStringList DapWalletModel::getWalletList() const
+{
+ QStringList walletList;
+ foreach (auto wallet, m_aWallets)
+ {
+ walletList.append(wallet.getName());
+ }
+ return walletList;
+}
+
+void DapWalletModel::appendWallet(const DapWallet &aWallet)
+{
+ m_aWallets.append(aWallet);
+
+ emit walletListChanged(getWalletList());
+
+ int lastIndex = m_aWallets.count() - 1;
+ beginInsertRows(QModelIndex(), lastIndex, lastIndex);
+ endInsertRows();
+}
+
+void DapWalletModel::appendToken(const QString &asWalletAddress, DapWalletToken* aToken)
+{
+ auto wallet = std::find_if(m_aWallets.begin(), m_aWallets.end(), [=] (const DapWallet& aWallet)
+ {
+ return aWallet.getAddresses().values().contains(asWalletAddress);
+ });
+
+ return wallet->addToken(aToken);
+}
+
+void DapWalletModel::removeWallet(const QString &asWalletAddress)
+{
+ int removeIndex = -1;
+ auto wallet = std::find_if(m_aWallets.cbegin(), m_aWallets.cend(), [=] (const DapWallet& aWallet)
+ {
+ return aWallet.getAddresses().values().contains(asWalletAddress);
+ });
+ removeIndex = m_aWallets.indexOf(*wallet);
+ m_aWallets.removeAt(removeIndex);
+
+ emit walletListChanged(getWalletList());
+
+ if(removeIndex == -1)
+ return;
+ beginRemoveRows(QModelIndex(), removeIndex, removeIndex);
+ endRemoveRows();
+}
+
+void DapWalletModel::removeWallet(const int aWalletIndex)
+{
+ if(aWalletIndex >= m_aWallets.count() || m_aWallets.count() < aWalletIndex)
+ return;
+ beginRemoveRows(QModelIndex(), aWalletIndex, aWalletIndex);
+ m_aWallets.removeAt(aWalletIndex);
+
+ emit walletListChanged(getWalletList());
+
+ endRemoveRows();
+}
+
+QHash<int, QByteArray> DapWalletModel::roleNames() const
+{
+ static const QHash<int, QByteArray> roles
+ {
+ { NameDisplayRole, "name" },
+ { BalanceDisplayRole, "balance" },
+ { AddressDisplayRole, "address" },
+ { IconDisplayRole, "iconPath" },
+ { NetworksDisplayRole, "networks" },
+ { TokensDisplayRole, "tokens" },
+ { WalletsDisplayRole, "walletList" }
+ };
+
+ return roles;
+}
diff --git a/models/DapWalletModel.h b/models/DapWalletModel.h
new file mode 100644
index 00000000..5819271b
--- /dev/null
+++ b/models/DapWalletModel.h
@@ -0,0 +1,57 @@
+#ifndef DAPWALLETMODEL_H
+#define DAPWALLETMODEL_H
+
+#include <QObject>
+#include <QAbstractListModel>
+#include <algorithm>
+#include <QList>
+
+#include "DapWallet.h"
+
+class DapWalletModel : public QAbstractListModel
+{
+ Q_OBJECT
+
+ QList<DapWallet> m_aWallets;
+
+ explicit DapWalletModel(QObject *parent = nullptr);
+
+public:
+ Q_PROPERTY(QStringList WalletList READ getWalletList NOTIFY walletListChanged)
+
+ enum DapWalletRole
+ {
+ NameDisplayRole = Qt::UserRole,
+ AddressDisplayRole,
+ BalanceDisplayRole,
+ IconDisplayRole,
+ NetworksDisplayRole,
+ TokensDisplayRole,
+ WalletsDisplayRole
+ };
+ Q_ENUM(DapWalletRole)
+
+ static DapWalletModel& getInstance();
+
+ int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+
+ QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+
+ QHash<int, QByteArray> roleNames() const override;
+
+ QList<QObject*> getTokens(const int aIndex) const;
+
+ QStringList getWalletList() const;
+
+signals:
+ void walletListChanged(const QStringList& aWalletList);
+
+public slots:
+
+ Q_INVOKABLE void appendWallet(const DapWallet& aWallet);
+ Q_INVOKABLE void appendToken(const QString& asWalletAddress, DapWalletToken* aToken);
+ Q_INVOKABLE void removeWallet(const QString& asWalletAddress);
+ Q_INVOKABLE void removeWallet(const int aWalletIndex);
+};
+
+#endif // DAPWALLETMODEL_H
diff --git a/serviceClient/DapServiceClient.cpp b/serviceClient/DapServiceClient.cpp
new file mode 100644
index 00000000..eaa9f880
--- /dev/null
+++ b/serviceClient/DapServiceClient.cpp
@@ -0,0 +1,150 @@
+#include "DapServiceClient.h"
+
+DapServiceClient::DapServiceClient(const QString& asServiceName, QObject *apParent)
+ : QObject(apParent), DapServiceClientNative(asServiceName), m_sServiceName(asServiceName)
+{
+ // Initialization of the service connection socket
+ m_pClientSocket = new DapUiSocket(this);
+ // Signal-slot connection broadcasting service connection error
+ connect(m_pClientSocket,static_cast<void(DapUiSocket::*)(DapUiSocketError)> (&DapUiSocket::error),
+ this, &DapServiceClient::handleSocketError);
+ // Signal-slot connection broadcasting signal of successful connection to the service
+ connect(m_pClientSocket,SIGNAL(connected()), this, SLOT(connectedToService()));
+ // Signal-slot connection transmitting a signal to disconnect from the service
+ connect(m_pClientSocket,SIGNAL(disconnected()), this, SLOT(disconnectFromService()));
+ // Signal-slot connection that reconnects to the service
+ connect(&m_reconnectTimer, SIGNAL(timeout()), this, SLOT(reconnectToService()));
+}
+
+/// Get a socket pointer.
+/// @return A pointer to a socket.
+DapUiSocket *DapServiceClient::getClientSocket() const
+{
+ return m_pClientSocket;
+}
+
+/// Establish a connection with the service when the latter is launched.
+void DapServiceClient::onServiceStarted()
+{
+ qInfo() << "Service started.";
+ connectToService();
+}
+
+/// Handle event of successful connection to the service.
+void DapServiceClient::connectedToService()
+{
+ qInfo() << "Connected to the service";
+ m_launchAttemptCounter = 0;
+ m_isServiceConnected = true;
+ stopReconnectingToService();
+ emit sigConnected();
+}
+
+/// Start the process of reconnecting to the service.
+void DapServiceClient::startReconnectingToService()
+{
+ if(!m_reconnectTimer.isActive()) {
+ qInfo() << "Start trying to reconnect to service";
+ m_reconnectTimer.start(RECONNECT_TIMEOUT_MS);
+ }
+}
+
+/// Stop the process of reconnecting to the service.
+void DapServiceClient::stopReconnectingToService()
+{
+ if(m_reconnectTimer.isActive())
+ {
+ m_reconnectTimer.stop();
+ qInfo() << "Reconnect timer stopped";
+ }
+}
+
+/// Handle socket error.
+/// @param aSocketEror Socket error code.
+void DapServiceClient::handleSocketError(DapUiSocketError aSocketEror)
+{
+ qDebug() << m_pClientSocket->errorString();
+ startReconnectingToService();
+ emit sigSocketError(aSocketEror);
+ emit sigSocketErrorString(m_pClientSocket->errorString());
+}
+
+/// Reconnect service.
+void DapServiceClient::reconnectToService()
+{
+ ++m_launchAttemptCounter;
+ DapServiceError resultInit = DapServiceError::NO_ERRORS;
+ if(m_launchAttemptCounter == NUMBER_LAUNCH_ATTEMPTS)
+ {
+ qCritical() << "Server not running after `serviceStart` operation";
+ QMessageBox::critical(Q_NULLPTR, DAP_BRAND, "Unable to start service", QMessageBox::Ok);
+ exit(-1);
+ }
+ else
+ {
+ resultInit = init();
+ }
+ if(resultInit == DapServiceError::NO_ERRORS)
+ {
+ connectToService();
+ }
+}
+
+/// Initiate the service monitor.
+DapServiceError DapServiceClient::init()
+{
+ DapServiceError result = DapServiceClientNative::init();
+
+ handleServiceError(result);
+
+ return result;
+}
+
+/// Handle service error.
+/// @param aServiceEror Service error code.
+void DapServiceClient::handleServiceError(DapServiceError aServiceEror)
+{
+ switch (aServiceEror)
+ {
+ case DapServiceError::NO_ERRORS:
+ break;
+ case DapServiceError::USER_COMMAND_ABORT:
+ QMessageBox::critical(Q_NULLPTR, DAP_BRAND, "User abort service comand", QMessageBox::Ok);
+ exit(-1);
+ case DapServiceError::UNABLE_START_SERVICE:
+ QMessageBox::critical(Q_NULLPTR, DAP_BRAND, "Start the service with administrator rights", QMessageBox::Ok);
+ qCritical() << "Start the service with administrator rights";
+ break;
+ case DapServiceError::UNABLE_STOP_SERVICE:
+ qCritical() << "Can't stop service";
+ break;
+ case DapServiceError::UNKNOWN_ERROR:
+ qCritical() << "Got unknown error";
+ break;
+ case DapServiceError::SERVICE_NOT_FOUND:
+ qCritical() << "Service not found";
+ break;
+ }
+ if(aServiceEror != DapServiceError::NO_ERRORS)
+ {
+ emit sigServiceError(aServiceEror);
+ }
+}
+
+/// Establish a connection with the service.
+void DapServiceClient::connectToService()
+{
+ if(m_pClientSocket->state() == QAbstractSocket::ConnectedState)
+ return;
+
+ qInfo() << "with parametr: " << DAP_BRAND;
+ m_pClientSocket->connectToServer(DAP_BRAND);
+}
+
+/// Handle service outage.
+void DapServiceClient::disconnectFromService()
+{
+ m_isServiceConnected = true;
+ startReconnectingToService();
+ emit sigDisconnected();
+}
diff --git a/serviceClient/DapServiceClient.h b/serviceClient/DapServiceClient.h
new file mode 100644
index 00000000..f3acd4c5
--- /dev/null
+++ b/serviceClient/DapServiceClient.h
@@ -0,0 +1,93 @@
+#ifndef DAPSERVICECLIENT_H
+#define DAPSERVICECLIENT_H
+
+#include <QObject>
+#include <QTimer>
+#include <QMessageBox>
+#include <QLocalSocket>
+#include <QLocalServer>
+
+#if defined(Q_OS_LINUX)
+#include "DapServiceClientNativeLinux.h"
+typedef class DapServiceClientNativeLinux DapServiceClientNative;
+#elif defined(Q_OS_WIN)
+#include "DapServiceClientNativeWin.h"
+typedef class DapServiceClientNativeWin DapServiceClientNative;
+#elif defined(Q_OS_MAC)
+#include "DapServiceClientNativeMacOS.h"
+typedef class DapServiceClientNativeMacOS DapServiceClientNative;
+#endif
+
+typedef QLocalSocket DapUiSocket;
+typedef QLocalServer DapUiServer;
+typedef QLocalSocket::LocalSocketError DapUiSocketError;
+
+class DapServiceClient : public QObject, public DapServiceClientNative
+{
+ Q_OBJECT
+ Q_DISABLE_COPY(DapServiceClient)
+
+ /// Reconnect interval.
+ const int RECONNECT_TIMEOUT_MS {5000};
+ /// The number of attempts to restart the service.
+ const size_t NUMBER_LAUNCH_ATTEMPTS {3};
+ /// The current number of attempts to restart the service.
+ size_t m_launchAttemptCounter {0};
+ /// Reconnect timer.
+ QTimer m_reconnectTimer;
+ /// Service connection socket.
+ DapUiSocket *m_pClientSocket {nullptr};
+
+ bool m_isServiceConnected {false};
+
+ const QString& m_sServiceName;
+
+public:
+ explicit DapServiceClient(const QString& asServiceName, QObject * apParent = nullptr);
+ /// Get a socket pointer.
+ /// @return A pointer to a socket.
+ DapUiSocket *getClientSocket() const;
+
+signals:
+ /// The signal emitted in case of successful connection to the service.
+ void sigConnected();
+ /// The signal emitted in case of successful disconnection from the service.
+ void sigDisconnected();
+ /// The signal emitted in the event of an error when connecting to the service.
+ /// @param asErrorMessage Socket error message.
+ void sigSocketErrorString(const QString& asErrorMessage);
+ /// The signal emitted in the event of an error when connecting to the service.
+ /// @param aSocketEror Socket error code.
+ void sigSocketError(DapUiSocketError aSocketEror);
+ /// The signal is emitted in case of an error when trying to start the service.
+ /// @param aServiceEror Service error code.
+ void sigServiceError(DapServiceError aServiceEror);
+
+protected slots:
+ /// Establish a connection with the service when the latter is launched.
+ void onServiceStarted();
+ /// Handle event of successful connection to the service.
+ void connectedToService();
+ /// Start the process of reconnecting to the service.
+ void startReconnectingToService();
+ /// Stop the process of reconnecting to the service.
+ void stopReconnectingToService();
+ /// Handle socket error.
+ /// @param aSocketEror Socket error code.
+ void handleSocketError(DapUiSocketError aSocketEror);
+ /// Reconnect service.
+ void reconnectToService();
+ /// Handle service error.
+ /// @param aServiceEror Service error code.
+ void handleServiceError(DapServiceError aServiceEror);
+
+public slots:
+ /// Initiate the service monitor.
+ virtual DapServiceError init() override;
+ /// Establish a connection with the service.
+ void connectToService();
+ /// Handle service outage.
+ void disconnectFromService();
+};
+
+#endif // DAPSERVICECLIENT_H
diff --git a/serviceClient/DapServiceClientNativeAbstract.cpp b/serviceClient/DapServiceClientNativeAbstract.cpp
new file mode 100644
index 00000000..4cce5996
--- /dev/null
+++ b/serviceClient/DapServiceClientNativeAbstract.cpp
@@ -0,0 +1,54 @@
+#include "DapServiceClientNativeAbstract.h"
+
+DapServiceClientNativeAbstract::DapServiceClientNativeAbstract(const QString &asServiceName)
+ : m_sServiceName(asServiceName)
+{
+ m_isServiceRunning = false;
+}
+
+DapServiceError DapServiceClientNativeAbstract::init()
+{
+ qInfo() << "DapServiceClientNativeAbstract::init()";
+ DapServiceError result = DapServiceError::NO_ERRORS;
+ if(!isServiceRunning())
+ {
+ qInfo() << "Install the service in the system";
+
+ result = serviceInstallAndRun();
+
+ if(result != DapServiceError::NO_ERRORS)
+ return result;
+
+ if(isServiceRunning())
+ {
+ onServiceStarted();
+ }
+ else
+ {
+ qCritical() << "Service not started after "
+ "'serviceInstallAndRun' operation!";
+ }
+ }
+ else
+ {
+ onServiceStarted();
+ }
+ return result;
+}
+
+void DapServiceClientNativeAbstract::onServiceInstalled()
+{
+ qInfo() << "DapServiceClientNativeAbstract::onServiceInstalled()";
+ if(isServiceRunning())
+ onServiceStarted();
+}
+
+void DapServiceClientNativeAbstract::onServiceStarted()
+{
+
+}
+
+void DapServiceClientNativeAbstract::onServiceStopped()
+{
+
+}
diff --git a/serviceClient/DapServiceClientNativeAbstract.h b/serviceClient/DapServiceClientNativeAbstract.h
new file mode 100644
index 00000000..82f9f309
--- /dev/null
+++ b/serviceClient/DapServiceClientNativeAbstract.h
@@ -0,0 +1,41 @@
+#ifndef DAPSERVICECLIENTNATIVEABSTRACT_H
+#define DAPSERVICECLIENTNATIVEABSTRACT_H
+
+#include <QTimer>
+#include <QDebug>
+
+enum class DapServiceError {
+ NO_ERRORS,
+ USER_COMMAND_ABORT,
+ UNABLE_START_SERVICE,
+ UNABLE_STOP_SERVICE,
+ SERVICE_NOT_FOUND,
+ UNKNOWN_ERROR
+};
+
+class DapServiceClientNativeAbstract
+{
+public:
+ DapServiceClientNativeAbstract(const QString& asServiceName);
+ virtual ~DapServiceClientNativeAbstract() { }
+
+ virtual bool isServiceRunning() = 0;
+
+ virtual DapServiceError serviceInstallAndRun() = 0;
+ virtual DapServiceError serviceStart() = 0;
+ virtual DapServiceError serviceStop() = 0;
+ virtual DapServiceError serviceRestart() = 0;
+
+public slots:
+ virtual DapServiceError init();
+protected:
+ bool m_isServiceRunning;
+ const QString& m_sServiceName;
+
+protected slots:
+ virtual void onServiceInstalled();
+ virtual void onServiceStarted();
+ virtual void onServiceStopped();
+};
+
+#endif // DAPSERVICECLIENTNATIVEABSTRACT_H
diff --git a/serviceClient/DapServiceClientNativeLinux.cpp b/serviceClient/DapServiceClientNativeLinux.cpp
new file mode 100644
index 00000000..3ee040c8
--- /dev/null
+++ b/serviceClient/DapServiceClientNativeLinux.cpp
@@ -0,0 +1,76 @@
+#include "DapServiceClientNativeLinux.h"
+
+#include <QtDebug>
+#include <QMessageBox>
+
+DapServiceClientNativeLinux::DapServiceClientNativeLinux(const QString& asServiceName)
+ : DapServiceClientNativeAbstract(asServiceName)
+{
+ QString dapServiceNameToLower = QString(m_sServiceName).toLower();
+ QString cmd = QString("ps -C %1 > /dev/null").arg(m_sServiceName);
+ m_checkIsServiceRunningCommand = strdup(cmd.toLatin1().data());
+
+ m_cmdTemplate = QString("service " + dapServiceNameToLower) + " %1";
+
+ qDebug() << "command for check is service running: " << m_checkIsServiceRunningCommand;
+}
+
+DapServiceClientNativeLinux::~DapServiceClientNativeLinux()
+{
+ delete m_checkIsServiceRunningCommand;
+}
+
+bool DapServiceClientNativeLinux::isServiceRunning()
+{
+ m_isServiceRunning =true;// (::system(m_checkIsServiceRunningCommand) == 0);
+ return m_isServiceRunning;
+}
+
+DapServiceError DapServiceClientNativeLinux::serviceRestart()
+{
+ qDebug() << "Restart service name" << m_cmdTemplate.arg("restart").toLatin1().data();
+
+ int retCode = ::system(m_cmdTemplate.arg("restart").toLatin1().data());
+ qDebug() << "Restart result code:" << retCode;
+ if(retCode != 0) {
+ return DapServiceError::USER_COMMAND_ABORT;
+ }
+
+ return DapServiceError::NO_ERRORS;
+}
+
+/**
+ * @brief SapNetworkClientNativeLinux::serviceStart
+ */
+DapServiceError DapServiceClientNativeLinux::serviceStart()
+{
+ // yes better use restart
+ int ret = ::system(m_cmdTemplate.arg("restart").toLatin1().data());
+ qDebug() << "serviceStart Result: " << ret;
+
+ if(ret != 0) {
+ return DapServiceError::USER_COMMAND_ABORT;
+ }
+
+ return DapServiceError::NO_ERRORS;
+}
+
+/**
+ * @brief SapServiceClientNativeLinux::serviceStop
+ */
+DapServiceError DapServiceClientNativeLinux::serviceStop()
+{
+ int ret = ::system(m_cmdTemplate.arg("stop").toLatin1().data());
+ qDebug() << "serviceStop result:" << ret;
+ if(ret != 0) {
+ return DapServiceError::USER_COMMAND_ABORT;
+ }
+ return DapServiceError::NO_ERRORS;
+}
+/**
+ * @brief SapServiceClientNativeLinux::serviceInstallAndRun
+ */
+DapServiceError DapServiceClientNativeLinux::serviceInstallAndRun()
+{
+ return serviceStart();
+}
diff --git a/serviceClient/DapServiceClientNativeLinux.h b/serviceClient/DapServiceClientNativeLinux.h
new file mode 100644
index 00000000..e8c57cd9
--- /dev/null
+++ b/serviceClient/DapServiceClientNativeLinux.h
@@ -0,0 +1,21 @@
+#ifndef DAPSERVICECLIENTNATIVELINUX_H
+#define DAPSERVICECLIENTNATIVELINUX_H
+
+#include "DapServiceClientNativeAbstract.h"
+
+class DapServiceClientNativeLinux : public DapServiceClientNativeAbstract
+{
+ const char* m_checkIsServiceRunningCommand;
+ QString m_cmdTemplate;
+public:
+ DapServiceClientNativeLinux(const QString& asServiceName);
+ ~DapServiceClientNativeLinux() override;
+ bool isServiceRunning() override;
+ DapServiceError serviceStart() override;
+ DapServiceError serviceRestart() override;
+
+ DapServiceError serviceStop() override;
+ DapServiceError serviceInstallAndRun() override;
+};
+
+#endif // DAPSERVICECLIENTNATIVELINUX_H
diff --git a/serviceClient/DapServiceClientNativeMacOS.cpp b/serviceClient/DapServiceClientNativeMacOS.cpp
new file mode 100644
index 00000000..3339b9e7
--- /dev/null
+++ b/serviceClient/DapServiceClientNativeMacOS.cpp
@@ -0,0 +1,76 @@
+#include "DapServiceClientNativeMacOS.h"
+
+#include <QtDebug>
+#include <QMessageBox>
+
+DapServiceClientNativeMacOS::DapServiceClientNativeMacOS(const QString &asServiceName)
+ : DapServiceClientNativeAbstract(asServiceName)
+{
+ QString dapServiceNameToLower = QString(m_sServiceName).toLower();
+ QString cmd = QString("ps -C %1 > /dev/null").arg(m_sServiceName);
+ m_checkIsServiceRunningCommand = strdup(cmd.toLatin1().data());
+
+ m_cmdTemplate = QString("service " + dapServiceNameToLower) + " %1";
+
+ qDebug() << "command for check is service running: " << m_checkIsServiceRunningCommand;
+}
+
+DapServiceClientNativeMacOS::~DapServiceClientNativeMacOS()
+{
+ delete m_checkIsServiceRunningCommand;
+}
+
+bool DapServiceClientNativeMacOS::isServiceRunning()
+{
+ m_isServiceRunning =true;// (::system(m_checkIsServiceRunningCommand) == 0);
+ return m_isServiceRunning;
+}
+
+DapServiceError DapServiceClientNativeMacOS::serviceRestart()
+{
+ qDebug() << "Restart service name" << m_cmdTemplate.arg("restart").toLatin1().data();
+
+ int retCode = ::system(m_cmdTemplate.arg("restart").toLatin1().data());
+ qDebug() << "Restart result code:" << retCode;
+ if(retCode != 0) {
+ return DapServiceError::USER_COMMAND_ABORT;
+ }
+
+ return DapServiceError::NO_ERRORS;
+}
+
+/**
+ * @brief SapNetworkClientNativeMacOS::serviceStart
+ */
+DapServiceError DapServiceClientNativeMacOS::serviceStart()
+{
+ // yes better use restart
+ int ret = ::system(m_cmdTemplate.arg("restart").toLatin1().data());
+ qDebug() << "serviceStart Result: " << ret;
+
+ if(ret != 0) {
+ return DapServiceError::USER_COMMAND_ABORT;
+ }
+
+ return DapServiceError::NO_ERRORS;
+}
+
+/**
+ * @brief SapServiceClientNativeMacOS::serviceStop
+ */
+DapServiceError DapServiceClientNativeMacOS::serviceStop()
+{
+ int ret = ::system(m_cmdTemplate.arg("stop").toLatin1().data());
+ qDebug() << "serviceStop result:" << ret;
+ if(ret != 0) {
+ return DapServiceError::USER_COMMAND_ABORT;
+ }
+ return DapServiceError::NO_ERRORS;
+}
+/**
+ * @brief SapServiceClientNativeMacOS::serviceInstallAndRun
+ */
+DapServiceError DapServiceClientNativeMacOS::serviceInstallAndRun()
+{
+ return serviceStart();
+}
diff --git a/serviceClient/DapServiceClientNativeMacOS.h b/serviceClient/DapServiceClientNativeMacOS.h
new file mode 100644
index 00000000..c04f37d5
--- /dev/null
+++ b/serviceClient/DapServiceClientNativeMacOS.h
@@ -0,0 +1,21 @@
+#ifndef DAPSERVICECLIENTNATIVEMACOS_H
+#define DAPSERVICECLIENTNATIVEMACOS_H
+
+#include "DapServiceClientNativeAbstract.h"
+
+class DapServiceClientNativeMacOS : public DapServiceClientNativeAbstract
+{
+ const char* m_checkIsServiceRunningCommand;
+ QString m_cmdTemplate;
+public:
+ DapServiceClientNativeMacOS(const QString& asServiceName);
+ ~DapServiceClientNativeMacOS() override;
+ bool isServiceRunning() override;
+ DapServiceError serviceStart() override;
+ DapServiceError serviceRestart() override;
+
+ DapServiceError serviceStop() override;
+ DapServiceError serviceInstallAndRun() override;
+};
+
+#endif // DAPSERVICECLIENTNATIVEMACOS_H
diff --git a/serviceClient/DapServiceClientNativeWin.cpp b/serviceClient/DapServiceClientNativeWin.cpp
new file mode 100644
index 00000000..a97fc9f3
--- /dev/null
+++ b/serviceClient/DapServiceClientNativeWin.cpp
@@ -0,0 +1,31 @@
+#include "DapServiceClientNativeWin.h"
+
+DapServiceClientNativeWin::DapServiceClientNativeWin(const QString& asServiceName)
+ : DapServiceClientNativeAbstract(asServiceName)
+{
+}
+
+bool DapServiceClientNativeWin::isServiceRunning()
+{
+ return true;
+}
+
+DapServiceError DapServiceClientNativeWin::serviceInstallAndRun() {
+ return DapServiceError::NO_ERRORS;
+}
+
+DapServiceError DapServiceClientNativeWin::serviceStart() {
+ return DapServiceError::NO_ERRORS;
+}
+
+DapServiceError DapServiceClientNativeWin::serviceRestart() {
+ return DapServiceError::NO_ERRORS;
+}
+
+DapServiceError DapServiceClientNativeWin::serviceStop() {
+ return DapServiceError::NO_ERRORS;
+}
+
+DapServiceClientNativeWin::~DapServiceClientNativeWin() {
+
+}
diff --git a/serviceClient/DapServiceClientNativeWin.h b/serviceClient/DapServiceClientNativeWin.h
new file mode 100644
index 00000000..868698ef
--- /dev/null
+++ b/serviceClient/DapServiceClientNativeWin.h
@@ -0,0 +1,19 @@
+#ifndef DAPSERVICECLIENTNATIVEWIN_H
+#define DAPSERVICECLIENTNATIVEWIN_H
+
+#include "DapServiceClientNativeAbstract.h"
+
+class DapServiceClientNativeWin : public DapServiceClientNativeAbstract
+{
+public:
+ DapServiceClientNativeWin(const QString& asServiceName);
+ ~DapServiceClientNativeWin() override;
+ bool isServiceRunning() override;
+ DapServiceError serviceStart() override;
+ DapServiceError serviceRestart() override;
+
+ DapServiceError serviceStop() override;
+ DapServiceError serviceInstallAndRun() override;
+};
+
+#endif // DAPSERVICECLIENTNATIVEWIN_H
--
GitLab