IT4Change/gradido
3
0
Fork 0
mirror of https://github.com/IT4Change/gradido.git synced 2025-12-13 07:45:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

move enum HederaNetworkType into namespace (and file) ServerConfig to use it for a server config option

Browse Source
This commit is contained in:
Dario 2020-11-09 18:44:19 +01:00 committed by Ulf Gebhardt
parent dfceb2a0d0
commit e5e4a07441
No known key found for this signature in database
GPG Key ID: 81308EFE29ABFEBD
15 changed files with 74 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/cpp/HTTPInterface/AdminHederaAccountPage.cpp
View File

@ -188,7 +188,7 @@ void AdminHederaAccountPage::handleRequest(Poco::Net::HTTPServerRequest& request
if(DataTypeConverter::strToInt(networkTypeString, networkType) != DataTypeConverter::NUMBER_PARSE_OKAY) {
addError(new Error("Int Convert Error", "Error converting network type to int"));
}
if(networkType < 0 || networkType >= (int)model::table::HEDERA_NET_COUNT) {
if(networkType < 0 || networkType >= (int)ServerConfig::HEDERA_NET_COUNT) {
addError(new Error("Network Type", "invalid value"));
}
}
@ -228,7 +228,7 @@ void AdminHederaAccountPage::handleRequest(Poco::Net::HTTPServerRequest& request
hedera_id->getModel()->getID(),
crypto_key->getModel()->getID(),
0,
(model::table::HederaNetworkType)networkType
(ServerConfig::HederaNetworkType)networkType
);
if(!hedera_account->getModel()->insertIntoDB(false)) {
addError(new Error("DB Error", "Error saving hedera account into DB"));
@ -414,13 +414,13 @@ void AdminHederaAccountPage::handleRequest(Poco::Net::HTTPServerRequest& request
responseStream << "\t\t\t<select class=\"form-control\" name=\"account-network-type\" id=\"account-network-type\">\n";
responseStream << "\t\t\t";
#line 301 "F:\\Gradido\\gradido_login_server\\src\\cpsp\\adminHederaAccount.cpsp"
for(int i = 0; i < model::table::HEDERA_NET_COUNT; i++) { responseStream << "\n";
for(int i = 0; i < ServerConfig::HEDERA_NET_COUNT; i++) { responseStream << "\n";
responseStream << "\t\t\t\t<option value=\"";
#line 302 "F:\\Gradido\\gradido_login_server\\src\\cpsp\\adminHederaAccount.cpsp"
responseStream << ( i );
responseStream << "\">";
#line 302 "F:\\Gradido\\gradido_login_server\\src\\cpsp\\adminHederaAccount.cpsp"
responseStream << ( model::table::HederaAccount::hederaNetworkTypeToString((model::table::HederaNetworkType)i) );
responseStream << ( model::table::HederaAccount::hederaNetworkTypeToString((ServerConfig::HederaNetworkType)i) );
responseStream << "</option>\n";
responseStream << "\t\t\t";
#line 303 "F:\\Gradido\\gradido_login_server\\src\\cpsp\\adminHederaAccount.cpsp"

11
src/cpp/ServerConfig.cpp
View File

@ -20,6 +20,8 @@
#include "Poco/DateTimeFormat.h"
#include "Poco/DateTimeFormatter.h"
#include "model/table/HederaAccount.h"
using Poco::Net::SSLManager;
using Poco::Net::Context;
@ -57,6 +59,7 @@ namespace ServerConfig {
std::string g_gRPCRelayServerFullURL;
MemoryBin* g_CryptoAppSecret = nullptr;
HederaConsensusMessageFormat g_ConsensusMessageFormat = HEDERA_CONSENSUS_FORMAT_BINARY;
HederaNetworkType g_HederaNetworkType = HEDERA_TESTNET;
#ifdef __linux__
#include <stdio.h>
@ -163,6 +166,8 @@ namespace ServerConfig {
return HEDERA_CONSENSUS_FORMAT_BINARY;
}
bool loadMnemonicWordLists()
{
@ -242,6 +247,12 @@ namespace ServerConfig {
auto hedera_consensus_message_format_string = cfg.getString("hedera.consensus.message_format", "bin");
g_ConsensusMessageFormat = getHederaConsensusMessageFormatFromString(hedera_consensus_message_format_string);
auto hedera_network_type_string = cfg.getString("hedera.nettype", "Testnet");
g_HederaNetworkType = model::table::HederaAccount::hederaNetworkTypeFromString(hedera_network_type_string);
if (HEDERA_UNKNOWN == g_HederaNetworkType) {
g_HederaNetworkType = HEDERA_TESTNET;
}
// app secret for encrypt user private keys
// TODO: encrypt with server admin key
auto app_secret_string = cfg.getString("crypto.app_secret", "");

8
src/cpp/ServerConfig.h
View File

@ -54,6 +54,13 @@ namespace ServerConfig {
HEDERA_CONSENSUS_FORMAT_BASE64_URLSAVE_NO_PADDING
};
enum HederaNetworkType {
HEDERA_MAINNET,
HEDERA_TESTNET,
HEDERA_NET_COUNT,
HEDERA_UNKNOWN
};
extern Mnemonic g_Mnemonic_WordLists[MNEMONIC_MAX];
@ -82,6 +89,7 @@ namespace ServerConfig {
extern MemoryBin* g_CryptoAppSecret;
extern AllowUnsecure g_AllowUnsecureFlags;
extern HederaConsensusMessageFormat g_ConsensusMessageFormat;
extern HederaNetworkType g_HederaNetworkType;
bool loadMnemonicWordLists();
bool initServerCrypto(const Poco::Util::LayeredConfiguration& cfg);

6
src/cpp/controller/HederaAccount.cpp
View File

@ -21,7 +21,7 @@ namespace controller {
{
}
Poco::AutoPtr<HederaAccount> HederaAccount::create(int user_id, int account_hedera_id, int account_key_id, Poco::UInt64 balance/* = 0*/, model::table::HederaNetworkType type/* = HEDERA_MAINNET*/)
Poco::AutoPtr<HederaAccount> HederaAccount::create(int user_id, int account_hedera_id, int account_key_id, Poco::UInt64 balance/* = 0*/, ServerConfig::HederaNetworkType type/* = HEDERA_MAINNET*/)
{
auto db = new model::table::HederaAccount(user_id, account_hedera_id, account_key_id, balance, type);
auto group = new HederaAccount(db);
@ -75,7 +75,7 @@ namespace controller {
return nullptr;
}
Poco::AutoPtr<HederaAccount> HederaAccount::pick(model::table::HederaNetworkType networkType, bool encrypted/* = false*/)
Poco::AutoPtr<HederaAccount> HederaAccount::pick(ServerConfig::HederaNetworkType networkType, bool encrypted/* = false*/)
{
auto cm = ConnectionManager::getInstance();
auto session = cm->getConnection(CONNECTION_MYSQL_LOGIN_SERVER);
@ -269,7 +269,7 @@ namespace controller {
{
std::stringstream ss;
auto model = getModel();
ss << model::table::HederaAccount::hederaNetworkTypeToString((model::table::HederaNetworkType)model->getNetworkType()) << " ";
ss << model::table::HederaAccount::hederaNetworkTypeToString((ServerConfig::HederaNetworkType)model->getNetworkType()) << " ";
ss << getHederaId()->getModel()->toString() << " " << ((double)model->getBalance() / 100000000.0) << " Hbar";
return ss.str();
}

4
src/cpp/controller/HederaAccount.h
View File

@ -18,14 +18,14 @@ namespace controller {
public:
~HederaAccount();
static Poco::AutoPtr<HederaAccount> create(int user_id, int account_hedera_id, int account_key_id, Poco::UInt64 balance = 0, model::table::HederaNetworkType type = model::table::HEDERA_MAINNET);
static Poco::AutoPtr<HederaAccount> create(int user_id, int account_hedera_id, int account_key_id, Poco::UInt64 balance = 0, ServerConfig::HederaNetworkType type = ServerConfig::HEDERA_MAINNET);
static std::vector<Poco::AutoPtr<HederaAccount>> load(const std::string& fieldName, int fieldValue);
static Poco::AutoPtr<HederaAccount> load(int id);
static Poco::AutoPtr<HederaAccount> load(Poco::AutoPtr<controller::HederaId> hederaId);
static std::vector<Poco::AutoPtr<HederaAccount>> listAll();
//! \brief for picking a account for paying transaction, mostly consensusSendMessage
static Poco::AutoPtr<HederaAccount> pick(model::table::HederaNetworkType networkType, bool encrypted = false);
static Poco::AutoPtr<HederaAccount> pick(ServerConfig::HederaNetworkType networkType, bool encrypted = false);
inline bool deleteFromDB() { return mDBModel->deleteFromDB(); }

2
src/cpp/controller/HederaId.cpp
View File

@ -33,7 +33,7 @@ namespace controller {
return nullptr;
}
Poco::AutoPtr<HederaId> HederaId::find(int groupId, model::table::HederaNetworkType networkType)
Poco::AutoPtr<HederaId> HederaId::find(int groupId, ServerConfig::HederaNetworkType networkType)
{
auto cm = ConnectionManager::getInstance();
auto session = cm->getConnection(CONNECTION_MYSQL_LOGIN_SERVER);

2
src/cpp/controller/HederaId.h
View File

@ -23,7 +23,7 @@ namespace controller {
static Poco::AutoPtr<HederaId> load(int id);
//! \return hedera topic id for group and network type (should exist only one)
static Poco::AutoPtr<HederaId> find(int groupId, model::table::HederaNetworkType networkType);
static Poco::AutoPtr<HederaId> find(int groupId, ServerConfig::HederaNetworkType networkType);
bool isExistInDB();

6
src/cpp/controller/NodeServer.cpp
View File

@ -93,11 +93,11 @@ namespace controller {
ORDER BY RAND()
LIMIT 1;
*/
NodeServerConnection NodeServer::pick(model::table::HederaNetworkType type, int group_id /*= 0*/)
NodeServerConnection NodeServer::pick(ServerConfig::HederaNetworkType type, int group_id /*= 0*/)
{
model::table::NodeServerType node_server_type = model::table::NODE_SERVER_NONE;
if (model::table::HEDERA_MAINNET) node_server_type = model::table::NODE_SERVER_HEDERA_MAINNET_NODE;
else if (model::table::HEDERA_TESTNET) node_server_type = model::table::NODE_SERVER_HEDERA_TESTNET_NODE;
if (ServerConfig::HEDERA_MAINNET) node_server_type = model::table::NODE_SERVER_HEDERA_MAINNET_NODE;
else if (ServerConfig::HEDERA_TESTNET) node_server_type = model::table::NODE_SERVER_HEDERA_TESTNET_NODE;
return pick(node_server_type, group_id);
}
NodeServerConnection NodeServer::pick(model::table::NodeServerType type, int group_id/* = 0*/)

2
src/cpp/controller/NodeServer.h
View File

@ -44,7 +44,7 @@ namespace controller {
static std::vector<Poco::AutoPtr<NodeServer>> load(model::table::NodeServerType type, int group_id = 0);
static std::vector<Poco::AutoPtr<NodeServer>> listAll();
// pick server randomly
static NodeServerConnection pick(model::table::HederaNetworkType type, int group_id = 0);
static NodeServerConnection pick(ServerConfig::HederaNetworkType type, int group_id = 0);
static NodeServerConnection pick(model::table::NodeServerType type, int group_id = 0);
bool deleteFromDB();

8
src/cpp/model/gradido/Transaction.cpp
View File

@ -54,7 +54,7 @@ namespace model {
return nullptr;
}
auto group_model = group->getModel();
auto network_type = table::HEDERA_TESTNET;
auto network_type = ServerConfig::g_HederaNetworkType;
auto topic_id = controller::HederaId::find(group_model->getID(), network_type);
if (topic_id.isNull()) {
@ -82,7 +82,7 @@ namespace model {
if (receiver.isNull() || !receiver->getModel()) {
return nullptr;
}
auto network_type = table::HEDERA_TESTNET;
auto network_type = ServerConfig::g_HederaNetworkType;
auto receiver_model = receiver->getModel();
auto topic_id = controller::HederaId::find(receiver_model->getGroupId(), network_type);
@ -113,7 +113,7 @@ namespace model {
//std::vector<Poco::AutoPtr<TransactionBody>> bodys;
auto sender_model = sender->getModel();
auto network_type = table::HEDERA_TESTNET;
auto network_type = ServerConfig::g_HederaNetworkType;
// LOCAL Transfer
if (receiverGroup.isNull() || sender_model->getGroupId() == receiverGroup->getModel()->getID())
{
@ -463,7 +463,7 @@ namespace model {
else
{
// send transaction via hedera
auto network_type = table::HEDERA_TESTNET;
auto network_type = ServerConfig::g_HederaNetworkType;
// TODO: get correct topic id for user group
//int user_group_id = 1;
//auto topic_id = controller::HederaId::find(user_group_id, network_type);

28
src/cpp/model/table/HederaAccount.cpp
View File

@ -11,7 +11,7 @@ namespace model {
}
HederaAccount::HederaAccount(int user_id, int account_hedera_id, int account_key_id, Poco::UInt64 balance/* = 0*/, HederaNetworkType type /*= HEDERA_MAINNET*/)
HederaAccount::HederaAccount(int user_id, int account_hedera_id, int account_key_id, Poco::UInt64 balance/* = 0*/, ServerConfig::HederaNetworkType type /*= ServerConfig::HEDERA_MAINNET*/)
: mUserId(user_id), mAccountHederaId(account_hedera_id), mAccountKeyId(account_key_id), mBalance(balance), mType(type)
{
@ -38,7 +38,7 @@ namespace model {
ss << "account crypto key id: " << std::to_string(mAccountKeyId) << std::endl;
// balance in tinybars, 100,000,000 tinybar = 1 HashBar
ss << "account balance: " << std::to_string((double)(mBalance) * 100000000.0) << " HBAR" << std::endl;
ss << "Hedera Net Type: " << hederaNetworkTypeToString((HederaNetworkType)mType) << std::endl;
ss << "Hedera Net Type: " << hederaNetworkTypeToString((ServerConfig::HederaNetworkType)mType) << std::endl;
ss << "last update: " << Poco::DateTimeFormatter::format(mUpdated, "%f.%m.%Y %H:%M:%S") << std::endl;
return ss.str();
@ -57,20 +57,32 @@ namespace model {
}
const char* HederaAccount::hederaNetworkTypeToString(HederaNetworkType type)
const char* HederaAccount::hederaNetworkTypeToString(ServerConfig::HederaNetworkType type)
{
switch (type) {
case HEDERA_MAINNET: return "Mainnet";
case HEDERA_TESTNET: return "Testnet";
case ServerConfig::HEDERA_MAINNET: return "Mainnet";
case ServerConfig::HEDERA_TESTNET: return "Testnet";
case ServerConfig::HEDERA_UNKNOWN: return "unknown";
default: return "<unknown>";
}
}
NodeServerType HederaAccount::networkTypeToNodeServerType(HederaNetworkType type)
ServerConfig::HederaNetworkType HederaAccount::hederaNetworkTypeFromString(const std::string& typeString)
{
if ("MAINNET" == typeString || "Mainnet" == typeString) {
return ServerConfig::HEDERA_MAINNET;
}
if ("TESTNET" == typeString || "Testnet" == typeString) {
return ServerConfig::HEDERA_TESTNET;
}
return ServerConfig::HEDERA_UNKNOWN;
}
NodeServerType HederaAccount::networkTypeToNodeServerType(ServerConfig::HederaNetworkType type)
{
switch (type) {
case HEDERA_MAINNET: return NODE_SERVER_HEDERA_MAINNET_NODE;
case HEDERA_TESTNET: return NODE_SERVER_HEDERA_TESTNET_NODE;
case ServerConfig::HEDERA_MAINNET: return NODE_SERVER_HEDERA_MAINNET_NODE;
case ServerConfig::HEDERA_TESTNET: return NODE_SERVER_HEDERA_TESTNET_NODE;
default: return NODE_SERVER_TYPE_NONE;
}
}

18
src/cpp/model/table/HederaAccount.h
View File

@ -1,7 +1,8 @@
#ifndef GRADIDO_LOGIN_SERVER_MODEL_TABLE_HEDERA_ACCOUNTS_INCLUDE
#define GRADIDO_LOGIN_SERVER_MODEL_TABLE_HEDERA_ACCOUNTS_INCLUDE
#include "ModelBase.h"
//#include "ModelBase.h"
#include "../../ServerConfig.h"
#include "Poco/Tuple.h"
#include "NodeServer.h"
@ -11,17 +12,13 @@ namespace model {
typedef Poco::Tuple<int, int, int, int, Poco::UInt64, int, Poco::DateTime> HederaAccountTuple;
enum HederaNetworkType {
HEDERA_MAINNET,
HEDERA_TESTNET,
HEDERA_NET_COUNT,
};
class HederaAccount : public ModelBase
{
public:
HederaAccount();
HederaAccount(int user_id, int account_hedera_id, int account_key_id, Poco::UInt64 balance = 0, HederaNetworkType type = HEDERA_MAINNET);
HederaAccount(int user_id, int account_hedera_id, int account_key_id, Poco::UInt64 balance = 0, ServerConfig::HederaNetworkType type = ServerConfig::HEDERA_MAINNET);
HederaAccount(const HederaAccountTuple& tuple);
~HederaAccount();
@ -30,8 +27,9 @@ namespace model {
std::string toString();
static const char* hederaNetworkTypeToString(HederaNetworkType type);
static NodeServerType networkTypeToNodeServerType(HederaNetworkType type);
static const char* hederaNetworkTypeToString(ServerConfig::HederaNetworkType type);
static NodeServerType networkTypeToNodeServerType(ServerConfig::HederaNetworkType type);
static ServerConfig::HederaNetworkType hederaNetworkTypeFromString(const std::string& typeString);
inline int getAccountHederaId() const { return mAccountHederaId; }
inline int getCryptoKeyId() const { return mAccountKeyId; }
@ -41,7 +39,7 @@ namespace model {
inline double getBalanceDouble() { return (double)mBalance / 100000000.0; }
std::string getBalanceString();
inline HederaNetworkType getNetworkType() { return (HederaNetworkType)mType; }
inline ServerConfig::HederaNetworkType getNetworkType() { return (ServerConfig::HederaNetworkType)mType; }
inline std::string getUpdatedString() { return Poco::DateTimeFormatter::format(mUpdated, "%f.%m.%Y %H:%M:%S"); }

2
src/cpp/tasks/SigningTransaction.cpp
View File

@ -165,7 +165,7 @@ int SigningTransaction::run() {
return -6;
}
auto network_type = model::table::HEDERA_TESTNET;
auto network_type = ServerConfig::HEDERA_TESTNET;
auto topic_id = controller::HederaId::find(1, network_type);
auto hedera_operator_account = controller::HederaAccount::pick(network_type, false);

8
src/cpsp/adminHederaAccount.cpsp
View File

@ -167,7 +167,7 @@
if(DataTypeConverter::strToInt(networkTypeString, networkType) != DataTypeConverter::NUMBER_PARSE_OKAY) {
addError(new Error("Int Convert Error", "Error converting network type to int"));
}
if(networkType < 0 || networkType >= (int)model::table::HEDERA_NET_COUNT) {
if(networkType < 0 || networkType >= (int)ServerConfig::HEDERA_NET_COUNT) {
addError(new Error("Network Type", "invalid value"));
}
}
@ -207,7 +207,7 @@
hedera_id->getModel()->getID(),
crypto_key->getModel()->getID(),
0,
(model::table::HederaNetworkType)networkType
(ServerConfig::HederaNetworkType)networkType
);
if(!hedera_account->getModel()->insertIntoDB(false)) {
addError(new Error("DB Error", "Error saving hedera account into DB"));
@ -298,8 +298,8 @@
<input class="form-control" id="account-public-key" type="text" name="account-public-key"/>
<label class="form-label" for="account-network-type">Network Type</label>
<select class="form-control" name="account-network-type" id="account-network-type">
<% for(int i = 0; i < model::table::HEDERA_NET_COUNT; i++) { %>
<option value="<%= i %>"><%= model::table::HederaAccount::hederaNetworkTypeToString((model::table::HederaNetworkType)i) %></option>
<% for(int i = 0; i < ServerConfig::HEDERA_NET_COUNT; i++) { %>
<option value="<%= i %>"><%= model::table::HederaAccount::hederaNetworkTypeToString((ServerConfig::HederaNetworkType)i) %></option>
<% } %>
</select>
<input class="center-form-submit form-button" type="submit" name="add" value="<%= gettext("Add Account") %>">

4
src/cpsp/adminTopic.cpsp
View File

@ -103,7 +103,9 @@
if(DataTypeConverter::strToInt(group_id_string, group_id) != DataTypeConverter::NUMBER_PARSE_OKAY) {
addError(new Error("Int convert error", "Error converting group_id to int"));
}
}
}
}