From 4bdc4865f75b9d581c3f1a6770ac78458e9667bc Mon Sep 17 00:00:00 2001 From: "crypro.zoidberg" Date: Thu, 4 Apr 2019 19:49:16 +0200 Subject: [PATCH] added safety code for GUI --- src/currency_core/account.cpp | 2 +- src/currency_core/currency_format_utils.cpp | 2 +- src/gui/qt-daemon/application/mainwindow.cpp | 258 +++++++++++++++++-- 3 files changed, 240 insertions(+), 22 deletions(-) diff --git a/src/currency_core/account.cpp b/src/currency_core/account.cpp index 37f5aab9..a291feb8 100644 --- a/src/currency_core/account.cpp +++ b/src/currency_core/account.cpp @@ -98,7 +98,7 @@ namespace currency //cut the last timestamp word from restore_dats std::list words; boost::split(words, restore_data_, boost::is_space()); - CHECK_AND_ASSERT_THROW_MES(words.size() == BRAINWALLET_DEFAULT_WORDS_COUNT, "Words count missmatch: " << words.size()); + CHECK_AND_ASSERT_MES(words.size() == BRAINWALLET_DEFAULT_WORDS_COUNT, false, "Words count missmatch: " << words.size()); std::string timestamp_word = words.back(); words.erase(--words.end()); diff --git a/src/currency_core/currency_format_utils.cpp b/src/currency_core/currency_format_utils.cpp index c1663dc8..b644fc56 100644 --- a/src/currency_core/currency_format_utils.cpp +++ b/src/currency_core/currency_format_utils.cpp @@ -1212,7 +1212,7 @@ namespace currency //--------------------------------------------------------------- std::string get_word_from_timstamp(uint64_t timestamp) { - uint64_t date_offset = timestamp ? timestamp - WALLET_BRAIN_DATE_OFFSET : 0; + uint64_t date_offset = timestamp > WALLET_BRAIN_DATE_OFFSET ? timestamp - WALLET_BRAIN_DATE_OFFSET : 0; uint64_t weeks_count = date_offset / WALLET_BRAIN_DATE_QUANTUM; CHECK_AND_ASSERT_THROW_MES(weeks_count < std::numeric_limits::max(), "internal error: unable to converto to uint32, val = " << weeks_count); uint32_t weeks_count_32 = static_cast(weeks_count); diff --git a/src/gui/qt-daemon/application/mainwindow.cpp b/src/gui/qt-daemon/application/mainwindow.cpp index 32a4c764..b06714e1 100644 --- a/src/gui/qt-daemon/application/mainwindow.cpp +++ b/src/gui/qt-daemon/application/mainwindow.cpp @@ -17,7 +17,7 @@ arg_type var_name = AUTO_VAL_INIT(var_name); \ view::api_response default_ar = AUTO_VAL_INIT(default_ar); \ if (!epee::serialization::load_t_from_json(var_name, param.toStdString())) \ -{ \ +{ \ default_ar.error_code = API_RETURN_CODE_BAD_ARG; \ return MAKE_RESPONSE(default_ar); \ } @@ -32,6 +32,20 @@ if (!epee::serialization::load_t_from_json(var_name, param.toStdString())) \ #define LOG_API_PARAMS(log_level) LOG_PRINT_BLUE(LOCAL_FUNCTION_DEF__ << "(" << param.toStdString() << ")", log_level) +#define CATCH_ENTRY_FAIL_API_RESPONCE() } \ + catch (const std::exception& ex) \ + { \ + LOG_ERROR("Exception catched, ERROR:" << ex.what()); \ + PREPARE_RESPONSE(view::api_void, err_resp); \ + err_resp.error_code = API_RETURN_CODE_INTERNAL_ERROR; \ + return MAKE_RESPONSE(err_resp); \ + } \ + catch(...) \ + { \ + PREPARE_RESPONSE(view::api_void, err_resp); \ + err_resp.error_code = API_RETURN_CODE_INTERNAL_ERROR; \ + return MAKE_RESPONSE(err_resp); \ + } #include "mainwindow.h" // @@ -107,7 +121,6 @@ MainWindow::MainWindow(): //workaround for macos broken tolower from std, very dirty hack bc_services::set_external_to_low_converter(convert_to_lower_via_qt); #endif - } MainWindow::~MainWindow() @@ -120,7 +133,9 @@ MainWindow::~MainWindow() void MainWindow::on_load_finished(bool ok) { + TRY_ENTRY(); LOG_PRINT("MainWindow::on_load_finished(ok = " << (ok ? "true" : "false") << ")", LOG_LEVEL_0); + CATCH_ENTRY2(void()); } @@ -128,26 +143,34 @@ void MainWindow::on_load_finished(bool ok) //------------- QString MainWindow::get_default_user_dir(const QString& param) { + TRY_ENTRY(); return tools::get_default_user_dir().c_str(); + CATCH_ENTRY_FAIL_API_RESPONCE(); } bool MainWindow::toggle_mining() { + TRY_ENTRY(); m_backend.toggle_pos_mining(); return true; + CATCH_ENTRY2(false); } QString MainWindow::get_exchange_last_top(const QString& params) { + TRY_ENTRY(); return QString(); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::get_tx_pool_info() { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_RESPONSE(currency::COMMAND_RPC_GET_POOL_INFO::response, ar); ar.error_code = m_backend.get_tx_pool_info(ar.response_data); return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } // bool MainWindow::store_config() // { @@ -156,26 +179,33 @@ QString MainWindow::get_tx_pool_info() QString MainWindow::get_default_fee() { + TRY_ENTRY(); return QString(std::to_string(m_backend.get_default_fee()).c_str()); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::get_options() { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_RESPONSE(view::gui_options, ar); m_backend.get_gui_options(ar.response_data); ar.error_code = API_RETURN_CODE_OK; return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } void MainWindow::tray_quit_requested() { + TRY_ENTRY(); LOG_PRINT_MAGENTA("[GUI]->[HTML] tray_quit_requested", LOG_LEVEL_0); emit quit_requested("{}"); + CATCH_ENTRY2(void()); } void MainWindow::closeEvent(QCloseEvent *event) { + TRY_ENTRY(); LOG_PRINT_L0("[GUI] CLOSE EVENT"); CHECK_AND_ASSERT_MES(m_gui_deinitialize_done_1 == m_backend_stopped_2, void(), "m_gui_deinitialize_done_1 != m_backend_stopped_2, m_gui_deinitialize_done_1 = " << m_gui_deinitialize_done_1 << "m_backend_stopped_2 = " << m_backend_stopped_2); @@ -201,10 +231,12 @@ void MainWindow::closeEvent(QCloseEvent *event) emit quit_requested("{}"); event->ignore(); } + CATCH_ENTRY2(void()); } std::string state_to_text(int s) { + TRY_ENTRY(); std::string res = epee::string_tools::int_to_hex(s); res += "("; if (s & Qt::WindowMinimized) @@ -218,10 +250,12 @@ std::string state_to_text(int s) res += ")"; return res; + CATCH_ENTRY2(""); } void MainWindow::changeEvent(QEvent *e) { + TRY_ENTRY(); switch (e->type()) { case QEvent::WindowStateChange: @@ -263,28 +297,32 @@ void MainWindow::changeEvent(QEvent *e) } QWidget::changeEvent(e); + CATCH_ENTRY2(void()); } bool MainWindow::store_app_config() { + TRY_ENTRY(); std::string conf_path = m_backend.get_config_folder() + "/" + GUI_INTERNAL_CONFIG; return tools::serialize_obj_to_file(m_config, conf_path); + CATCH_ENTRY2(false); } bool MainWindow::load_app_config() { + TRY_ENTRY(); std::string conf_path = m_backend.get_config_folder() + "/" + GUI_INTERNAL_CONFIG; return tools::unserialize_obj_from_file(m_config, conf_path); + CATCH_ENTRY2(false); } bool MainWindow::init(const std::string& htmlPath) { + TRY_ENTRY(); //QtWebEngine::initialize(); init_tray_icon(htmlPath); set_html_path(htmlPath); - - m_backend.subscribe_to_core_events(this); bool r = QSslSocket::supportsSsl(); @@ -304,17 +342,21 @@ bool MainWindow::init(const std::string& htmlPath) m_view->setContextMenuPolicy(Qt::ContextMenuPolicy::NoContextMenu); return true; + CATCH_ENTRY2(false); } void MainWindow::on_menu_show() { + TRY_ENTRY(); qDebug() << "Context menu: show()"; this->show(); this->activateWindow(); + CATCH_ENTRY2(void()); } void MainWindow::init_tray_icon(const std::string& htmlPath) { + TRY_ENTRY(); if (!QSystemTrayIcon::isSystemTrayAvailable()) { LOG_PRINT_L0("System tray is unavailable"); @@ -356,10 +398,12 @@ void MainWindow::init_tray_icon(const std::string& htmlPath) connect(m_tray_icon.get(), SIGNAL(activated(QSystemTrayIcon::ActivationReason)), this, SLOT(trayIconActivated(QSystemTrayIcon::ActivationReason))); m_tray_icon->show(); + CATCH_ENTRY2(void()); } void MainWindow::bool_toggle_icon(const QString& param) { + TRY_ENTRY(); std::string path; if (param == "blocked") @@ -370,17 +414,21 @@ void MainWindow::bool_toggle_icon(const QString& param) QIcon qi(path.c_str()); qi.setIsMask(true); m_tray_icon->setIcon(qi); + CATCH_ENTRY2(void()); } QString MainWindow::get_log_file() { + TRY_ENTRY(); std::string buff; epee::file_io_utils::load_last_n_from_file_to_string(log_space::log_singletone::get_actual_log_file_path(), 1000000, buff); return QString::fromStdString(buff); + CATCH_ENTRY2(""); } void MainWindow::store_window_pos() { + TRY_ENTRY(); QPoint pos = this->pos(); QSize sz = this->size(); m_config.m_window_position.first = pos.x(); @@ -388,9 +436,11 @@ void MainWindow::store_window_pos() m_config.m_window_size.first = sz.height(); m_config.m_window_size.second = sz.width(); + CATCH_ENTRY2(void()); } void MainWindow::store_pos(bool consider_showed) { + TRY_ENTRY(); m_config.is_maximazed = this->isMaximized(); //here position supposed to be filled from last unserialize or filled on maximize handler if (!m_config.is_maximazed) @@ -398,9 +448,11 @@ void MainWindow::store_pos(bool consider_showed) if (consider_showed) m_config.is_showed = this->isVisible(); + CATCH_ENTRY2(void()); } void MainWindow::restore_pos(bool consider_showed) { + TRY_ENTRY(); if (m_config.is_maximazed) { this->setWindowState(windowState() | Qt::WindowMaximized); @@ -426,9 +478,11 @@ void MainWindow::restore_pos(bool consider_showed) this->showMinimized(); } + CATCH_ENTRY2(void()); } void MainWindow::trayIconActivated(QSystemTrayIcon::ActivationReason reason) { + TRY_ENTRY(); if (reason == QSystemTrayIcon::ActivationReason::Trigger) { if ( !(this->windowState() & Qt::WindowMinimized)) @@ -443,46 +497,58 @@ void MainWindow::trayIconActivated(QSystemTrayIcon::ActivationReason reason) } + CATCH_ENTRY2(void()); } void MainWindow::load_file(const QString &fileName) { + TRY_ENTRY(); LOG_PRINT_L0("Loading html from path: " << fileName.toStdString()); m_view->load(QUrl::fromLocalFile(QFileInfo(fileName).absoluteFilePath())); + CATCH_ENTRY2(void()); } QString MainWindow::set_clipboard(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); QClipboard *clipboard = QApplication::clipboard(); clipboard->setText(param); - return "OK"; + return API_RETURN_CODE_OK; + CATCH_ENTRY2(API_RETURN_CODE_INTERNAL_ERROR); } QString MainWindow::get_clipboard() { + TRY_ENTRY(); LOG_API_TIMING(); QClipboard *clipboard = QApplication::clipboard(); return clipboard->text(); + CATCH_ENTRY2(API_RETURN_CODE_INTERNAL_ERROR); } QString MainWindow::on_request_quit() { + TRY_ENTRY(); LOG_PRINT_MAGENTA("[HTML]->[GUI] on_request_quit", LOG_LEVEL_0); m_gui_deinitialize_done_1 = true; m_backend.send_stop_signal(); - return "OK"; + return API_RETURN_CODE_OK; + CATCH_ENTRY2(API_RETURN_CODE_INTERNAL_ERROR); } bool MainWindow::do_close() { + TRY_ENTRY(); this->close(); return true; + CATCH_ENTRY2(false); } bool MainWindow::show_inital() { + TRY_ENTRY(); if (load_app_config()) restore_pos(true); else @@ -497,10 +563,12 @@ bool MainWindow::show_inital() m_config.is_showed = true; } return true; + CATCH_ENTRY2(false); } bool MainWindow::on_backend_stopped() { + TRY_ENTRY(); LOG_PRINT_L0("[BACKEND]->[GUI] on_backend_stopped"); m_backend_stopped_2 = true; //m_deinitialize_done = true; @@ -510,10 +578,12 @@ bool MainWindow::on_backend_stopped() /*bool r = */QMetaObject::invokeMethod(this, "do_close", Qt::QueuedConnection); // } return true; + CATCH_ENTRY2(false); } bool MainWindow::update_daemon_status(const view::daemon_status_info& info) { + TRY_ENTRY(); //this->update_daemon_state(info); std::string json_str; epee::serialization::store_t_to_json(info, json_str); @@ -527,26 +597,34 @@ bool MainWindow::update_daemon_status(const view::daemon_status_info& info) QMetaObject::invokeMethod(this, "update_daemon_state", Qt::QueuedConnection, Q_ARG(QString, json_str.c_str())); m_last_update_daemon_status_json = json_str; return true; + CATCH_ENTRY2(false); } bool MainWindow::show_msg_box(const std::string& message) { + TRY_ENTRY(); QMessageBox::information(this, "Error", message.c_str(), QMessageBox::Ok); return true; + CATCH_ENTRY2(false); } bool MainWindow::init_backend(int argc, char* argv[]) { + TRY_ENTRY(); return m_backend.init(argc, argv, this); + CATCH_ENTRY2(false); } QString MainWindow::is_remnotenode_mode_preconfigured() { - return "FALSE"; + TRY_ENTRY(); + return API_RETURN_CODE_FALSE; + CATCH_ENTRY2(API_RETURN_CODE_INTERNAL_ERROR); } QString MainWindow::start_backend(const QString& params) { + TRY_ENTRY(); view::start_backend_params sbp = AUTO_VAL_INIT(sbp); view::api_response ar = AUTO_VAL_INIT(ar); @@ -564,28 +642,34 @@ QString MainWindow::start_backend(const QString& params) } ar.error_code = API_RETURN_CODE_OK; return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } bool MainWindow::update_wallet_status(const view::wallet_status_info& wsi) { + TRY_ENTRY(); m_wallet_states->operator [](wsi.wallet_id) = wsi.wallet_state; std::string json_str; epee::serialization::store_t_to_json(wsi, json_str); LOG_PRINT_L0(get_wallet_log_prefix(wsi.wallet_id) + "SENDING SIGNAL -> [update_wallet_status]:" << std::endl << json_str ); QMetaObject::invokeMethod(this, "update_wallet_status", Qt::QueuedConnection, Q_ARG(QString, json_str.c_str())); return true; + CATCH_ENTRY2(false); } bool MainWindow::set_options(const view::gui_options& opt) { + TRY_ENTRY(); std::string json_str; epee::serialization::store_t_to_json(opt, json_str); LOG_PRINT_L0("SENDING SIGNAL -> [set_options]:" << std::endl << json_str); QMetaObject::invokeMethod(this, "set_options", Qt::QueuedConnection, Q_ARG(QString, json_str.c_str())); return true; + CATCH_ENTRY2(false); } bool MainWindow::nativeEventFilter(const QByteArray &eventType, void *message, long *result) { + TRY_ENTRY(); #ifdef WIN32 MSG *msg = static_cast< MSG * >(message); if (msg->message == WM_QUERYENDSESSION) @@ -595,22 +679,26 @@ bool MainWindow::nativeEventFilter(const QByteArray &eventType, void *message, l } #endif return false; + CATCH_ENTRY2(false); } bool MainWindow::update_wallets_info(const view::wallets_summary_info& wsi) { + TRY_ENTRY(); std::string json_str; epee::serialization::store_t_to_json(wsi, json_str); LOG_PRINT_L0("SENDING SIGNAL -> [update_wallets_info]"<< std::endl << json_str ); QMetaObject::invokeMethod(this, "update_wallets_info", Qt::QueuedConnection, Q_ARG(QString, json_str.c_str())); return true; + CATCH_ENTRY2(false); } bool MainWindow::money_transfer(const view::transfer_event_info& tei) { + TRY_ENTRY(); std::string json_str; epee::serialization::store_t_to_json(tei, json_str); @@ -650,10 +738,12 @@ bool MainWindow::money_transfer(const view::transfer_event_info& tei) show_notification(title, msg); return true; + CATCH_ENTRY2(false); } bool MainWindow::money_transfer_cancel(const view::transfer_event_info& tei) { + TRY_ENTRY(); std::string json_str; epee::serialization::store_t_to_json(tei, json_str); @@ -663,17 +753,21 @@ bool MainWindow::money_transfer_cancel(const view::transfer_event_info& tei) return true; + CATCH_ENTRY2(false); } bool MainWindow::wallet_sync_progress(const view::wallet_sync_progres_param& p) { + TRY_ENTRY(); LOG_PRINT_L2(get_wallet_log_prefix(p.wallet_id) + "SENDING SIGNAL -> [wallet_sync_progress]" << " wallet_id: " << p.wallet_id << ": " << p.progress << "%"); //this->wallet_sync_progress(epee::serialization::store_t_to_json(p).c_str()); QMetaObject::invokeMethod(this, "wallet_sync_progress", Qt::QueuedConnection, Q_ARG(QString, epee::serialization::store_t_to_json(p).c_str())); return true; + CATCH_ENTRY2(false); } bool MainWindow::set_html_path(const std::string& path) { + TRY_ENTRY(); //init_tray_icon(path); #ifdef _MSC_VER load_file(std::string(path + "/index.html").c_str()); @@ -682,38 +776,48 @@ bool MainWindow::set_html_path(const std::string& path) load_file(QString((std::string("") + path + "/index.html").c_str())); #endif return true; + CATCH_ENTRY2(false); } bool MainWindow::pos_block_found(const currency::block& block_found) { + TRY_ENTRY(); std::stringstream ss; ss << "Found Block h = " << currency::get_block_height(block_found); LOG_PRINT_L0("SENDING SIGNAL -> [update_pos_mining_text]"); //this->update_pos_mining_text(ss.str().c_str()); QMetaObject::invokeMethod(this, "update_pos_mining_text", Qt::QueuedConnection, Q_ARG(QString, ss.str().c_str())); return true; + CATCH_ENTRY2(false); } QString MainWindow::get_version() { + TRY_ENTRY(); return PROJECT_VERSION_LONG; + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::get_os_version() { + TRY_ENTRY(); return tools::get_os_version_string().c_str(); + CATCH_ENTRY2(API_RETURN_CODE_INTERNAL_ERROR); } QString MainWindow::get_alias_coast(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::struct_with_one_t_type, lvl); view::get_alias_coast_response resp; resp.error_code = m_backend.get_alias_coast(lvl.v, resp.coast); return epee::serialization::store_t_to_json(resp).c_str(); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::set_localization_strings(const QString param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::set_localization_request, lr); view::api_response resp; @@ -733,10 +837,12 @@ QString MainWindow::set_localization_strings(const QString param) LOG_PRINT_L0("New localization set, language title: " << lr.language_title << ", strings " << lr.strings.size()); } return epee::serialization::store_t_to_json(resp).c_str(); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::request_alias_registration(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); //return que_call2("request_alias_registration", param, [this](const view::request_alias_param& tp, view::api_response& ar){ PREPARE_ARG_FROM_JSON(view::request_alias_param, tp); @@ -754,9 +860,11 @@ QString MainWindow::request_alias_registration(const QString& param) ar.response_data.tx_blob_size = currency::get_object_blobsize(res_tx); ar.error_code = API_RETURN_CODE_OK; return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::request_alias_update(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::request_alias_param, tp); PREPARE_RESPONSE(view::transfer_response, ar); @@ -773,9 +881,11 @@ QString MainWindow::request_alias_update(const QString& param) ar.response_data.tx_blob_size = currency::get_object_blobsize(res_tx); ar.error_code = API_RETURN_CODE_OK; return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::transfer(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); //return que_call2("transfer", json_transfer_object, [this](const view::transfer_params& tp, view::api_response& ar){ PREPARE_ARG_FROM_JSON(view::transfer_params, tp); @@ -796,11 +906,14 @@ QString MainWindow::transfer(const QString& param) ar.response_data.tx_hash = string_tools::pod_to_hex(currency::get_transaction_hash(res_tx)); ar.response_data.tx_blob_size = currency::get_object_blobsize(res_tx); return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } void MainWindow::message_box(const QString& msg) { + TRY_ENTRY(); show_msg_box(msg.toStdString()); + CATCH_ENTRY2(void()); } struct serialize_variant_visitor : public boost::static_visitor @@ -815,12 +928,15 @@ struct serialize_variant_visitor : public boost::static_visitor template std::string serialize_variant(const t_variant& v) { + TRY_ENTRY(); return boost::apply_visitor(serialize_variant_visitor(), v); + CATCH_ENTRY2(""); } void MainWindow::on_core_event(const std::string event_name, const currency::core_event_v& e) { + TRY_ENTRY(); //at the moment we don't forward CORE_EVENT_BLOCK_ADDEDevent to GUI if (CORE_EVENT_BLOCK_ADDED == event_name) return; @@ -828,10 +944,12 @@ void MainWindow::on_core_event(const std::string event_name, const currency::cor m_events.m_que.push_back(currency::core_event()); m_events.m_que.back().details = currency::core_event_v(e); m_events.m_que.back().method = event_name; + CATCH_ENTRY2(void()); } std::string get_events_que_json_string(const std::list& eq, std::string& methods_list) { + TRY_ENTRY(); //t the moment portable_storage is not supporting polymorphic objects lists, so //there is no hope to make serialization with variant list, lets handle it manual std::stringstream ss; @@ -851,10 +969,12 @@ std::string get_events_que_json_string(const std::list& eq } ss << "]}"; return ss.str(); + CATCH_ENTRY2(API_RETURN_CODE_INTERNAL_ERROR); } void MainWindow::on_complete_events() { + TRY_ENTRY(); if (m_events.m_que.size()) { std::string methods_list; @@ -874,14 +994,18 @@ void MainWindow::on_complete_events() m_events.m_que.clear(); } + CATCH_ENTRY2(void()); } void MainWindow::on_clear_events() { + TRY_ENTRY(); m_events.m_que.clear(); + CATCH_ENTRY2(void()); } QString MainWindow::get_secure_app_data(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); view::password_data pwd = AUTO_VAL_INIT(pwd); @@ -917,10 +1041,12 @@ QString MainWindow::get_secure_app_data(const QString& param) } return app_data_buff.substr(sizeof(app_data_file_binary_header)).c_str(); + CATCH_ENTRY2(API_RETURN_CODE_INTERNAL_ERROR); } QString MainWindow::store_app_data(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); view::api_response ar; ar.error_code = API_RETURN_CODE_FAIL; @@ -940,9 +1066,11 @@ QString MainWindow::store_app_data(const QString& param) //ar.error_code = store_to_file((m_backend.get_config_folder() + "/" + GUI_CONFIG_FILENAME).c_str(), param).toStdString(); return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::is_file_exist(const QString& path) { + TRY_ENTRY(); try{ bool r = file_io_utils::is_file_exist(path.toStdWString()); if (r) @@ -960,9 +1088,11 @@ QString MainWindow::is_file_exist(const QString& path) { return API_RETURN_CODE_ALREADY_EXISTS; } + CATCH_ENTRY2(API_RETURN_CODE_INTERNAL_ERROR); } QString MainWindow::store_to_file(const QString& path, const QString& buff) { + TRY_ENTRY(); try{ bool r = file_io_utils::save_string_to_file_throw(path.toStdWString(), buff.toStdString()); if (r) @@ -982,18 +1112,22 @@ QString MainWindow::store_to_file(const QString& path, const QString& buff) } + CATCH_ENTRY2(API_RETURN_CODE_INTERNAL_ERROR); } QString MainWindow::get_app_data() { + TRY_ENTRY(); LOG_API_TIMING(); std::string app_data_buff; file_io_utils::load_file_to_string(m_backend.get_config_folder() + "/" + GUI_CONFIG_FILENAME, app_data_buff); return app_data_buff.c_str(); + CATCH_ENTRY2(API_RETURN_CODE_INTERNAL_ERROR); } QString MainWindow::store_secure_app_data(const QString& param, const QString& pass) { + TRY_ENTRY(); LOG_API_TIMING(); if (!tools::create_directories_if_necessary(m_backend.get_config_folder())) { @@ -1018,10 +1152,12 @@ QString MainWindow::store_secure_app_data(const QString& param, const QString& p ar.error_code = API_RETURN_CODE_FAIL; return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::have_secure_app_data() { + TRY_ENTRY(); LOG_API_TIMING(); view::api_response ar = AUTO_VAL_INIT(ar); @@ -1032,9 +1168,11 @@ QString MainWindow::have_secure_app_data() ar.error_code = API_RETURN_CODE_FALSE; return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::drop_secure_app_data() { + TRY_ENTRY(); LOG_API_TIMING(); view::api_response ar = AUTO_VAL_INIT(ar); @@ -1044,9 +1182,11 @@ QString MainWindow::drop_secure_app_data() else ar.error_code = API_RETURN_CODE_FALSE; return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::get_all_aliases() { + TRY_ENTRY(); LOG_API_TIMING(); //PREPARE_ARG_FROM_JSON(view::struct_with_one_t_type, param); PREPARE_RESPONSE(view::alias_set, rsp); @@ -1055,30 +1195,38 @@ QString MainWindow::get_all_aliases() QString res = MAKE_RESPONSE(rsp); LOG_PRINT_GREEN("GET_ALL_ALIASES: res: " << rsp.error_code << ", count: " << rsp.response_data.aliases.size() << ", string buff size: " << res.size(), LOG_LEVEL_1); return res; + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::get_alias_info_by_address(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_RESPONSE(currency::alias_rpc_details, rsp); rsp.error_code = m_backend.get_alias_info_by_address(param.toStdString(), rsp.response_data); return MAKE_RESPONSE(rsp); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::get_alias_info_by_name(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_RESPONSE(currency::alias_rpc_details, rsp); rsp.error_code = m_backend.get_alias_info_by_name(param.toStdString(), rsp.response_data); return MAKE_RESPONSE(rsp); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::validate_address(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); view::address_validation_response ar = AUTO_VAL_INIT(ar); ar.error_code = m_backend.validate_address(param.toStdString(), ar.payment_id); return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::set_log_level(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::struct_with_one_t_type, lvl); epee::log_space::get_set_log_detalisation_level(true, lvl.v); @@ -1086,14 +1234,17 @@ QString MainWindow::set_log_level(const QString& param) LOG_PRINT("[LOG LEVEL]: set to " << lvl.v, LOG_LEVEL_MIN); return MAKE_RESPONSE(default_ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::get_log_level(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_RESPONSE(view::struct_with_one_t_type, ar); ar.response_data.v = epee::log_space::get_set_log_detalisation_level(); ar.error_code = API_RETURN_CODE_OK; return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } // QString MainWindow::dump_all_offers() @@ -1127,12 +1278,15 @@ QString MainWindow::get_log_level(const QString& param) QString MainWindow::webkit_launched_script() { + TRY_ENTRY(); m_last_update_daemon_status_json.clear(); return ""; + CATCH_ENTRY2(API_RETURN_CODE_INTERNAL_ERROR); } //////////////////// QString MainWindow::show_openfile_dialog(const QString& param) { + TRY_ENTRY(); view::system_filedialog_request ofdr = AUTO_VAL_INIT(ofdr); view::system_filedialog_response ofdres = AUTO_VAL_INIT(ofdres); if (!epee::serialization::load_t_from_json(ofdr, param.toStdString())) @@ -1154,11 +1308,13 @@ QString MainWindow::show_openfile_dialog(const QString& param) ofdres.error_code = API_RETURN_CODE_OK; ofdres.path = path.toStdString(); return MAKE_RESPONSE(ofdres); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::show_savefile_dialog(const QString& param) { + TRY_ENTRY(); PREPARE_ARG_FROM_JSON(view::system_filedialog_request, ofdr); view::system_filedialog_response ofdres = AUTO_VAL_INIT(ofdres); @@ -1175,10 +1331,12 @@ QString MainWindow::show_savefile_dialog(const QString& param) ofdres.error_code = API_RETURN_CODE_OK; ofdres.path = path.toStdString(); return MAKE_RESPONSE(ofdres); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::close_wallet(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); //return que_call2("close_wallet", param, [this](const view::wallet_id_obj& owd, view::api_response& ar){ PREPARE_ARG_FROM_JSON(view::wallet_id_obj, owd); @@ -1186,25 +1344,30 @@ QString MainWindow::close_wallet(const QString& param) ar.error_code = m_backend.close_wallet(owd.wallet_id); return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::get_contracts(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::wallet_id_obj, owd); PREPARE_RESPONSE(view::contracts_array, ar); ar.error_code = m_backend.get_contracts(owd.wallet_id, ar.response_data.contracts); return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::create_proposal(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::create_proposal_param, cpp); PREPARE_RESPONSE(view::contracts_array, ar); ar.error_code = m_backend.create_proposal(cpp.wallet_id, cpp.details, cpp.payment_id, cpp.expiration_period, cpp.fee, cpp.b_fee); return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } @@ -1212,16 +1375,19 @@ QString MainWindow::create_proposal(const QString& param) QString MainWindow::accept_proposal(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::wallet_and_contract_id_param, waip); PREPARE_RESPONSE(view::api_void, ar); ar.error_code = m_backend.accept_proposal(waip.wallet_id, waip.contract_id); return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::release_contract(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::accept_proposal_param, rcp); PREPARE_RESPONSE(view::api_void, ar); @@ -1229,10 +1395,12 @@ QString MainWindow::release_contract(const QString& param) ar.error_code = m_backend.release_contract(rcp.wallet_id, rcp.contract_id, rcp.release_type); return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::request_cancel_contract(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::crequest_cancel_contract_param, rcp); PREPARE_RESPONSE(view::api_void, ar); @@ -1240,10 +1408,12 @@ QString MainWindow::request_cancel_contract(const QString& param) ar.error_code = m_backend.request_cancel_contract(rcp.wallet_id, rcp.contract_id, rcp.fee, rcp.expiration_period); return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::accept_cancel_contract(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::wallet_and_contract_id_param, wci); PREPARE_RESPONSE(view::api_void, ar); @@ -1251,31 +1421,36 @@ QString MainWindow::accept_cancel_contract(const QString& param) ar.error_code = m_backend.accept_cancel_contract(wci.wallet_id, wci.contract_id); return MAKE_RESPONSE(ar); - + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::generate_wallet(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); //return que_call2("generate_wallet", param, [this](const view::open_wallet_request& owd, view::api_response& ar){ PREPARE_ARG_FROM_JSON(view::open_wallet_request, owd); PREPARE_RESPONSE(view::open_wallet_response, ar); ar.error_code = m_backend.generate_wallet(epee::string_encoding::utf8_to_wstring(owd.path), owd.pass, ar.response_data); return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::restore_wallet(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); //return que_call2("restore_wallet", param, [this](const view::restore_wallet_request& owd, view::api_response& ar){ PREPARE_ARG_FROM_JSON(view::restore_wallet_request, owd); PREPARE_RESPONSE(view::open_wallet_response, ar); ar.error_code = m_backend.restore_wallet(epee::string_encoding::utf8_to_wstring(owd.path), owd.pass, owd.restore_key, ar.response_data); return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::open_wallet(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); //return que_call2("open_wallet", param, [this](const view::open_wallet_request& owd, view::api_response& ar){ @@ -1283,42 +1458,51 @@ QString MainWindow::open_wallet(const QString& param) PREPARE_RESPONSE(view::open_wallet_response, ar); ar.error_code = m_backend.open_wallet(epee::string_encoding::utf8_to_wstring(owd.path), owd.pass, ar.response_data); return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::get_my_offers(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); //return que_call2("open_wallet", param, [this](const view::open_wallet_request& owd, view::api_response& ar){ PREPARE_ARG_FROM_JSON(bc_services::core_offers_filter, f); PREPARE_RESPONSE(currency::COMMAND_RPC_GET_ALL_OFFERS::response, ar); ar.error_code = m_backend.get_my_offers(f, ar.response_data.offers); return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::get_fav_offers(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::get_fav_offers_request, f); PREPARE_RESPONSE(currency::COMMAND_RPC_GET_ALL_OFFERS::response, ar); ar.error_code = m_backend.get_fav_offers(f.ids, f.filter, ar.response_data.offers); return MAKE_RESPONSE(ar); - + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::is_pos_allowed() { + TRY_ENTRY(); LOG_API_TIMING(); return m_backend.is_pos_allowed().c_str(); + CATCH_ENTRY2(API_RETURN_CODE_INTERNAL_ERROR); } QString MainWindow::run_wallet(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::wallet_id_obj, wio); default_ar.error_code = m_backend.run_wallet(wio.wallet_id); return MAKE_RESPONSE(default_ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::resync_wallet(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); //return que_call2("get_wallet_info", param, [this](const view::wallet_id_obj& a, view::api_response& ar){ PREPARE_ARG_FROM_JSON(view::wallet_id_obj, a); @@ -1326,31 +1510,24 @@ QString MainWindow::resync_wallet(const QString& param) ar.error_code = m_backend.resync_wallet(a.wallet_id); return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } -// QString MainWindow::get_all_offers(const QString& param) -// { -// LOG_API_TIMING(); -// //return que_call2("get_all_offers", param, [this](const view::api_void& a, view::api_response& ar){ -// // PREPARE_ARG_FROM_JSON(view::api_void, a); -// PREPARE_RESPONSE(currency::COMMAND_RPC_GET_ALL_OFFERS::response, ar); -// ar.error_code = m_backend.get_all_offers(ar.response_data); -// return MAKE_RESPONSE(ar); -// } - - QString MainWindow::get_offers_ex(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); //return que_call2("get_offers_ex", param, [this](const bc_services::core_offers_filter& f, view::api_response& ar){ PREPARE_ARG_FROM_JSON(bc_services::core_offers_filter, f); PREPARE_RESPONSE(currency::COMMAND_RPC_GET_ALL_OFFERS::response, ar); ar.error_code = m_backend.get_offers_ex(f, ar.response_data.offers, ar.response_data.total_offers); return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::push_offer(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); LOG_API_PARAMS(LOG_LEVEL_2); //return que_call2("push_offer", param, [this](const view::push_offer_param& a, view::api_response& ar){ @@ -1369,10 +1546,12 @@ QString MainWindow::push_offer(const QString& param) ar.response_data.tx_blob_size = currency::get_object_blobsize(res_tx); ar.error_code = API_RETURN_CODE_OK; return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::cancel_offer(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); LOG_API_PARAMS(LOG_LEVEL_2); // return que_call2("cancel_offer", param, [this](const view::cancel_offer_param& a, view::api_response& ar){ @@ -1390,10 +1569,12 @@ QString MainWindow::cancel_offer(const QString& param) ar.response_data.tx_blob_size = currency::get_object_blobsize(res_tx); ar.error_code = API_RETURN_CODE_OK; return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::push_update_offer(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); LOG_API_PARAMS(LOG_LEVEL_2); //return que_call2("cancel_offer", param, [this](const bc_services::update_offer_details& a, view::api_response& ar){ @@ -1411,20 +1592,24 @@ QString MainWindow::push_update_offer(const QString& param) ar.response_data.tx_blob_size = currency::get_object_blobsize(res_tx); ar.error_code = API_RETURN_CODE_OK; return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::get_recent_transfers(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::get_recent_transfers_request, a); PREPARE_RESPONSE(view::transfers_array, ar); ar.error_code = m_backend.get_recent_transfers(a.wallet_id, a.offest, a.count, ar.response_data); return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::get_mining_history(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); //return prepare_call("get_mining_history", param, [this](const view::wallet_id_obj& a, view::api_response& ar) { PREPARE_ARG_FROM_JSON(view::wallet_id_obj, a); @@ -1436,62 +1621,78 @@ QString MainWindow::get_mining_history(const QString& param) ar.error_code = API_RETURN_CODE_OK; return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::start_pos_mining(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::wallet_id_obj, wo); default_ar.error_code = m_backend.start_pos_mining(wo.wallet_id); return MAKE_RESPONSE(default_ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::stop_pos_mining(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::wallet_id_obj, wo); default_ar.error_code = m_backend.stop_pos_mining(wo.wallet_id); return MAKE_RESPONSE(default_ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::get_smart_wallet_info(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::wallet_id_obj, wo); PREPARE_RESPONSE(view::get_restore_info_response, ar); ar.error_code = m_backend.get_wallet_restore_info(wo.wallet_id, ar.response_data.restore_key); return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::get_mining_estimate(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::request_mining_estimate, me); PREPARE_RESPONSE(view::response_mining_estimate, ar); ar.error_code = m_backend.get_mining_estimate(me.amount_coins, me.time, ar.response_data.final_amount, ar.response_data.all_coins_and_pos_diff_rate, ar.response_data.days_estimate); return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::backup_wallet_keys(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::backup_keys_request, me); default_ar.error_code = m_backend.backup_wallet(me.wallet_id, epee::string_encoding::utf8_to_wstring(me.path)); return MAKE_RESPONSE(default_ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::reset_wallet_password(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::reset_pass_request, me); default_ar.error_code = m_backend.reset_wallet_password(me.wallet_id, me.pass); return MAKE_RESPONSE(default_ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::is_wallet_password_valid(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::reset_pass_request, me); default_ar.error_code = m_backend.is_wallet_password_valid(me.wallet_id, me.pass); return MAKE_RESPONSE(default_ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::is_autostart_enabled() { + TRY_ENTRY(); LOG_API_TIMING(); view::api_response ar; @@ -1501,10 +1702,12 @@ QString MainWindow::is_autostart_enabled() ar.error_code = API_RETURN_CODE_FALSE; return MAKE_RESPONSE(ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::toggle_autostart(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::struct_with_one_t_type, as); @@ -1514,16 +1717,20 @@ QString MainWindow::toggle_autostart(const QString& param) default_ar.error_code = API_RETURN_CODE_FAIL; return MAKE_RESPONSE(default_ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::check_available_sources(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::api_request_t >, sources); return m_backend.check_available_sources(sources.wallet_id, sources.req_data).c_str(); + CATCH_ENTRY2(API_RETURN_CODE_INTERNAL_ERROR); } QString MainWindow::open_url_in_browser(const QString& param) { + TRY_ENTRY(); QString prefix = "https://"; if (!QDesktopServices::openUrl(QUrl(prefix + param))) { @@ -1532,20 +1739,26 @@ QString MainWindow::open_url_in_browser(const QString& param) } LOG_PRINT_L0("[Open URL]: " << param.toStdString()); return API_RETURN_CODE_OK; + CATCH_ENTRY2(API_RETURN_CODE_INTERNAL_ERROR); } QString MainWindow::is_valid_restore_wallet_text(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); return m_backend.is_valid_brain_restore_data(param.toStdString()).c_str(); + CATCH_ENTRY2(API_RETURN_CODE_INTERNAL_ERROR); } void MainWindow::contextMenuEvent(QContextMenuEvent * event) { + TRY_ENTRY(); + CATCH_ENTRY2(void()); } QString MainWindow::print_text(const QString& param) { + TRY_ENTRY(); LOG_API_TIMING(); PREPARE_ARG_FROM_JSON(view::print_text_param, ptp); @@ -1572,20 +1785,24 @@ QString MainWindow::print_text(const QString& param) default_ar.error_code = API_RETURN_CODE_OK; LOG_PRINT_L0("[PRINT_TEXT] default_ar.error_code = " << default_ar.error_code); return MAKE_RESPONSE(default_ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } QString MainWindow::print_log(const QString& param) { + TRY_ENTRY(); PREPARE_ARG_FROM_JSON(view::print_log_params, plp); LOG_PRINT("[GUI_LOG]" << plp.msg, plp.log_level); default_ar.error_code = API_RETURN_CODE_OK; return MAKE_RESPONSE(default_ar); + CATCH_ENTRY_FAIL_API_RESPONCE(); } void MainWindow::show_notification(const std::string& title, const std::string& message) { + TRY_ENTRY(); LOG_PRINT_L1("system notification: \"" << title << "\", \"" << message << "\""); // it's expected that title and message are utf-8 encoded! @@ -1598,6 +1815,7 @@ void MainWindow::show_notification(const std::string& title, const std::string& // use native notification system on macOS notification_helper::show(title, message); #endif + CATCH_ENTRY2(void()); }