Slic3r::GUI::HMSQuery Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/HMS.hpp>

Collaboration diagram for Slic3r::GUI::HMSQuery:

Public Member Functions
	HMSQuery ()
	~HMSQuery ()
void	clear_hms_info ()
wxString	query_hms_msg (const MachineObject *obj, const std::string &long_error_code)
wxString	query_hms_msg (const std::string &dev_id, const std::string &long_error_code)
bool	is_internal_error (const MachineObject *obj, int print_error)
wxString	query_print_error_msg (const MachineObject *obj, int print_error)
wxString	query_print_error_msg (const std::string &dev_id, int print_error)
wxString	query_print_image_action (const MachineObject *obj, int print_error, std::vector< int > &button_action)
wxImage	query_image_from_local (const wxString &image_name)

Static Public Member Functions
static std::string	hms_language_code ()
static std::string	build_query_params (std::string &lang)

Protected Attributes
std::unordered_map< std::string, nlohmann::json >	m_hms_info_jsons
std::unordered_map< std::string, nlohmann::json >	m_hms_action_jsons
std::unordered_map< wxString, wxImage >	m_hms_local_images
std::mutex	m_hms_mutex
std::unordered_map< std::string, std::time_t >	m_cloud_hms_last_update_time

Private Member Functions
void	init_hms_info (const std::string &dev_type_id)
void	copy_from_data_dir_to_local ()
int	download_hms_related (const std::string &hms_type, const std::string &dev_id_type, nlohmann::json *receive_json)
int	load_from_local (const std::string &hms_type, const std::string &dev_id_type, nlohmann::json *receive_json, std::string &version_info)
int	save_to_local (std::string lang, std::string hms_type, std::string dev_id_type, nlohmann::json save_json)
std::string	get_hms_file (std::string hms_type, std::string lang=std::string("en"), std::string dev_id_type="")
std::string	get_dev_id_type (const MachineObject *obj) const
wxString	_query_hms_msg (const std::string &dev_id_type, const std::string &long_error_code, const std::string &lang_code=std::string("en"))
bool	_is_internal_error (const std::string &dev_id_type, const std::string &long_error_code, const std::string &lang_code=std::string("en"))
wxString	_query_error_msg (const std::string &dev_id_type, const std::string &long_error_code, const std::string &lang_code=std::string("en"))
wxString	_query_error_image_action (const std::string &dev_id_type, const std::string &long_error_code, std::vector< int > &button_action)

Detailed Description

Constructor & Destructor Documentation

HMSQuery()

Slic3r::GUI::HMSQuery::HMSQuery ( )

inline

{ }

~HMSQuery()

Slic3r::GUI::HMSQuery::~HMSQuery ( )

inline

{ clear_hms_info(); };

References clear_hms_info().

Here is the call graph for this function:

Member Function Documentation

_is_internal_error()

bool Slic3r::GUI::HMSQuery::_is_internal_error ( const std::string & dev_id_type, const std::string & long_error_code, const std::string & lang_code = std::string("en") )

private

{
    init_hms_info(dev_id_type);
    auto iter = m_hms_info_jsons.find(dev_id_type);
    if (iter == m_hms_info_jsons.end()) { return false; }
 
    const json &m_hms_info_json = iter->second;
    if (m_hms_info_json.contains("device_error")) {
        if (m_hms_info_json["device_error"].contains(lang_code)) {
            for (auto item = m_hms_info_json["device_error"][lang_code].begin(); item != m_hms_info_json["device_error"][lang_code].end(); item++) {
                if (item->contains("ecode") && boost::to_upper_copy((*item)["ecode"].get<std::string>()) == error_code) {
                    if (item->contains("intro")) { return wxString::FromUTF8((*item)["intro"].get<std::string>()).IsEmpty(); }
                }
            }
        } else {
            // return first language
            if (!m_hms_info_json["device_error"].empty()) {
                for (auto lang : m_hms_info_json["device_error"]) {
                    for (auto item = lang.begin(); item != lang.end(); item++) {
                        if (item->contains("ecode") && boost::to_upper_copy((*item)["ecode"].get<std::string>()) == error_code) {
                            if (item->contains("intro")) { return wxString::FromUTF8((*item)["intro"].get<std::string>()).IsEmpty(); }
                        }
                    }
                }
            }
        }
    }
 
    return false;
}

References Slic3r::Geometry::contains(), Slic3r::empty(), init_hms_info(), and m_hms_info_jsons.

Referenced by is_internal_error().

Here is the call graph for this function:

Here is the caller graph for this function:

_query_error_image_action()

wxString Slic3r::GUI::HMSQuery::_query_error_image_action ( const std::string & dev_id_type, const std::string & long_error_code, std::vector< int > & button_action )

private

{
    init_hms_info(dev_id_type);
 
    auto iter = m_hms_action_jsons.find(dev_id_type);
    if (iter == m_hms_action_jsons.end())
    {
        return wxEmptyString;
    }
 
    const json& m_hms_action_json = iter->second;
    if (m_hms_action_json.contains("data")) {
        for (auto item = m_hms_action_json["data"].begin(); item != m_hms_action_json["data"].end(); item++) {
            if (item->contains("ecode") && boost::to_upper_copy((*item)["ecode"].get<std::string>()) == long_error_code) {
                if (item->contains("device") && (boost::to_upper_copy((*item)["device"].get<std::string>()) == dev_id_type ||
                    (*item)["device"].get<std::string>() == "default")) {
                    if (item->contains("actions")) {
                        for (auto item_actions = (*item)["actions"].begin(); item_actions != (*item)["actions"].end(); item_actions++) {
                            button_action.emplace_back(item_actions->get<int>());
                        }
                    }
                    if (item->contains("image")) {
                        return wxString::FromUTF8((*item)["image"].get<std::string>());
                    }
                }
            }
        }
    }
    else {
        BOOST_LOG_TRIVIAL(info) << "data is not exists";
        return wxEmptyString;
    }
    return wxEmptyString;
}

References init_hms_info(), and m_hms_action_jsons.

Referenced by query_print_image_action().

Here is the call graph for this function:

Here is the caller graph for this function:

_query_error_msg()

wxString Slic3r::GUI::HMSQuery::_query_error_msg ( const std::string & dev_id_type, const std::string & long_error_code, const std::string & lang_code = std::string("en") )

private

{
    init_hms_info(dev_id_type);
    auto iter = m_hms_info_jsons.find(dev_id_type);
    if (iter == m_hms_info_jsons.end())
    {
        return wxEmptyString;
    }
 
    const json& m_hms_info_json = iter->second;
    if (m_hms_info_json.contains("device_error")) {
        if (m_hms_info_json["device_error"].contains(lang_code)) {
            for (auto item = m_hms_info_json["device_error"][lang_code].begin(); item != m_hms_info_json["device_error"][lang_code].end(); item++) {
                if (item->contains("ecode") && boost::to_upper_copy((*item)["ecode"].get<std::string>()) == error_code) {
                    if (item->contains("intro")) {
                        return wxString::FromUTF8((*item)["intro"].get<std::string>());
                    }
                }
            }
            BOOST_LOG_TRIVIAL(info) << "hms: query_error_msg, not found error_code = " << error_code;
        } else {
            BOOST_LOG_TRIVIAL(error) << "hms: query_error_msg, do not contains lang_code = " << lang_code;
            // return first language
            if (!m_hms_info_json["device_error"].empty()) {
                for (auto lang : m_hms_info_json["device_error"]) {
                    for (auto item = lang.begin(); item != lang.end(); item++) {
                        if (item->contains("ecode") && boost::to_upper_copy((*item)["ecode"].get<std::string>()) == error_code) {
                            if (item->contains("intro")) {
                                return wxString::FromUTF8((*item)["intro"].get<std::string>());
                            }
                        }
                    }
                }
            }
        }
    }
    else {
        BOOST_LOG_TRIVIAL(info) << "device_error is not exists";
        return wxEmptyString;
    }
 
    return wxEmptyString;
}

References Slic3r::Geometry::contains(), Slic3r::empty(), init_hms_info(), and m_hms_info_jsons.

Referenced by query_print_error_msg(), and query_print_error_msg().

Here is the call graph for this function:

Here is the caller graph for this function:

_query_hms_msg()

wxString Slic3r::GUI::HMSQuery::_query_hms_msg ( const std::string & dev_id_type, const std::string & long_error_code, const std::string & lang_code = std::string("en") )

private

{
    if (long_error_code.empty())
    {
        return wxEmptyString;
    }
 
    init_hms_info(dev_id_type);
    auto iter = m_hms_info_jsons.find(dev_id_type);
    if (iter == m_hms_info_jsons.end())
    {
        BOOST_LOG_TRIVIAL(error) << "there are no hms info for the device";
        return wxEmptyString;
    }
 
    const json& m_hms_info_json = iter->second;
    if (!m_hms_info_json.is_object())
    {
        BOOST_LOG_TRIVIAL(error) << "the hms info is not a valid json object";
        return wxEmptyString;
    }
 
    const json& device_hms_json = m_hms_info_json.value("device_hms", json());
    if (device_hms_json.is_null() || !device_hms_json.is_object())
    {
        BOOST_LOG_TRIVIAL(error) << "there are no valid json object named device_hms";
        return wxEmptyString;
    }
 
    const json& device_hms_msg_json = device_hms_json.value(lang_code, json());
    if (device_hms_msg_json.is_null())
    {
        BOOST_LOG_TRIVIAL(error) << "hms: query_hms_msg, do not contains lang_code = " << lang_code;
        if (lang_code.empty()) /*traverse all if lang_code is empty*/
        {
            for (const auto& lang_item : device_hms_json)
            {
                for (const auto& msg_item : lang_item)
                {
                    if (msg_item.is_object())
                    {
                        const std::string& error_code = msg_item.value("ecode", json()).get<std::string>();
                        if (boost::to_upper_copy(error_code) == long_error_code && msg_item.contains("intro"))
                        {
                            BOOST_LOG_TRIVIAL(info) << "retry without lang_code successed.";
                            return wxString::FromUTF8(msg_item["intro"].get<std::string>());
                        }
                    }
                }
            }
        }
 
        return wxEmptyString;
    }
 
    for (const auto& item : device_hms_msg_json)
    {
        if (item.is_object())
        {
            const std::string& error_code = item.value("ecode", json()).get<std::string>();
            if (boost::to_upper_copy(error_code) == long_error_code && item.contains("intro"))
            {
                return wxString::FromUTF8(item["intro"].get<std::string>());
            }
        }
    }
 
    BOOST_LOG_TRIVIAL(error) << "hms: query_hms_msg, do not contains valid message, lang_code = " << lang_code << " long_error_code = " << long_error_code;
    return wxEmptyString;
}

References init_hms_info(), and m_hms_info_jsons.

Referenced by query_hms_msg(), and query_hms_msg().

Here is the call graph for this function:

Here is the caller graph for this function:

build_query_params()

std::string Slic3r::GUI::HMSQuery::build_query_params ( std::string & lang )

static

{
    std::string lang_code = HMSQuery::hms_language_code();
    lang = lang_code;
    std::string query_params = (boost::format("lang=%1%") % lang_code).str();
    return query_params;
}

References hms_language_code().

Referenced by download_hms_related(), and Slic3r::GUI::get_hms_info_version().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_hms_info()

void Slic3r::GUI::HMSQuery::clear_hms_info

(

)

{
    std::unique_lock unique_lock(m_hms_mutex);
    m_hms_info_jsons.clear();
    m_hms_action_jsons.clear();
    m_cloud_hms_last_update_time.clear();
}

References m_cloud_hms_last_update_time, m_hms_action_jsons, m_hms_info_jsons, and m_hms_mutex.

Referenced by ~HMSQuery().

Here is the caller graph for this function:

copy_from_data_dir_to_local()

void Slic3r::GUI::HMSQuery::copy_from_data_dir_to_local ( )

private

{
    const fs::path& from_dir = fs::path(Slic3r::resources_dir()) / HMS_PATH;
    const fs::path& to_dir = fs::path(Slic3r::data_dir()) / HMS_PATH;
    _copy_dir(from_dir, to_dir);
}

References Slic3r::GUI::_copy_dir(), Slic3r::data_dir(), HMS_PATH, and Slic3r::resources_dir().

Referenced by init_hms_info().

Here is the call graph for this function:

Here is the caller graph for this function:

download_hms_related()

int Slic3r::GUI::HMSQuery::download_hms_related ( const std::string & hms_type, const std::string & dev_id_type, nlohmann::json * receive_json )

private

{
    std::string local_version = "0";
    load_from_local(hms_type, dev_id_type, receive_json, local_version);
 
    AppConfig* config = wxGetApp().app_config;
    if (!config) return -1;
    if (should_disable_hms()) return -1;
 
    std::string hms_host = wxGetApp().app_config->get_hms_host();
    std::string lang;
    std::string query_params = HMSQuery::build_query_params(lang);
    std::string url;
    if (hms_type.compare(QUERY_HMS_INFO) == 0) {
        url = (boost::format("https://%1%/query.php?%2%") % hms_host % query_params).str();
    }
    else if (hms_type.compare(QUERY_HMS_ACTION) == 0) {
        url = (boost::format("https://%1%/hms/GetActionImage.php?") % hms_host).str();
    }
 
    if (!local_version.empty()) { url += (url.find('?') != std::string::npos ? "&" : "?") + (boost::format("v=%1%") % local_version).str(); }
 
    if (!dev_id_type.empty()) { url += (url.find('?') != std::string::npos ? "&" : "?") + (boost::format("d=%1%") % dev_id_type).str(); }
 
 
    bool to_save_local = false;
    json j;
 
    BOOST_LOG_TRIVIAL(info) << "hms: download url = " << url;
    Slic3r::Http http = Slic3r::Http::get(url);
    http.on_complete([receive_json, hms_type, &to_save_local, &j, & local_version](std::string body, unsigned status) {
        try {
            j = json::parse(body);
            if (j.contains("result")) {
                if (j["result"] == 0 && j.contains("data")) {
 
                    if (!j.contains("ver"))
                    {
                        return;
                    }
 
                    const std::string& remote_ver = DevJsonValParser::get_longlong_val(j["ver"]);
                    if (remote_ver <= local_version)
                    {
                        return;
                    }
                    (*receive_json)["version"] = remote_ver;
 
                    if (hms_type.compare(QUERY_HMS_INFO) == 0)
                    {
                        (*receive_json) = j["data"];
                        to_save_local = true;
                    }
                    else if (hms_type.compare(QUERY_HMS_ACTION) == 0)
                    {
                        (*receive_json)["data"] = j["data"];
                        to_save_local = true;
                    }
                } else if (j["result"] == 201){
                    BOOST_LOG_TRIVIAL(info) << "HMSQuery: HMS info is the latest version";
                }else{
                    BOOST_LOG_TRIVIAL(info) << "HMSQuery: update hms info error = " << j["result"].get<int>();
                }
            }
        } catch (...) {
            ;
        }
        })
        .timeout_max(20)
        .on_error([](std::string body, std::string error, unsigned status) {
            BOOST_LOG_TRIVIAL(error) << "HMSQuery: update hms info error = " << error << ", body = " << body << ", status = " << status;
        }).perform_sync();
 
        if (to_save_local && !receive_json->empty()) {
            save_to_local(lang, hms_type, dev_id_type, j);
        }
    return 0;
}

References build_query_params(), Slic3r::Http::get(), Slic3r::AppConfig::get_hms_host(), Slic3r::DevJsonValParser::get_longlong_val(), Slic3r::http, load_from_local(), QUERY_HMS_ACTION, QUERY_HMS_INFO, save_to_local(), and should_disable_hms().

Referenced by init_hms_info().

Here is the call graph for this function:

Here is the caller graph for this function:

get_dev_id_type()

std::string Slic3r::GUI::HMSQuery::get_dev_id_type ( const MachineObject * obj ) const

private

{
    if (obj)
    {
        return obj->get_dev_id().substr(0, 3);
    }
 
    return std::string();
}

References Slic3r::MachineObject::get_dev_id().

Referenced by is_internal_error(), query_hms_msg(), query_print_error_msg(), and query_print_image_action().

Here is the call graph for this function:

Here is the caller graph for this function:

get_hms_file()

std::string Slic3r::GUI::HMSQuery::get_hms_file ( std::string hms_type, std::string lang = std::string("en"), std::string dev_id_type = "" )

private

{
    //return hms action filename
    if (hms_type.compare(QUERY_HMS_ACTION) == 0) {
        return (boost::format("hms_action_%1%.json") % dev_id_type).str();
    }
    //return hms filename
    return (boost::format("hms_%1%_%2%.json") % lang % dev_id_type).str();
}

References QUERY_HMS_ACTION.

Referenced by load_from_local(), and save_to_local().

Here is the caller graph for this function:

hms_language_code()

std::string Slic3r::GUI::HMSQuery::hms_language_code ( )

static

{
    AppConfig* config = wxGetApp().app_config;
    if (!config)
        // set language code to en by default
        return "en";
    std::string lang_code = wxGetApp().app_config->get_language_code();
    // Orca: the HMS host ships no catalog for these locales, so fall back to english to avoid empty texts + retries
    if (lang_code.compare("uk") == 0
        || lang_code.compare("cs") == 0
        || lang_code.compare("ru") == 0
        || lang_code.compare("tr") == 0
        || lang_code.compare("pt") == 0
        || lang_code.compare("ko") == 0
        )
    {
        BOOST_LOG_TRIVIAL(info) << "HMS: using english for lang_code = " << lang_code;
        return "en";
    }
    else if (lang_code.empty()) {
        // set language code to en by default
        return "en";
    }
    return lang_code;
}

References Slic3r::AppConfig::get_language_code().

Referenced by build_query_params(), Slic3r::GUI::get_hms_wiki_url(), is_internal_error(), load_from_local(), query_hms_msg(), query_hms_msg(), query_print_error_msg(), and query_print_error_msg().

Here is the call graph for this function:

Here is the caller graph for this function:

init_hms_info()

void Slic3r::GUI::HMSQuery::init_hms_info ( const std::string & dev_type_id )

private

{
    std::unique_lock unique_lock(m_hms_mutex);
    if (package_dev_id_types.count(dev_type_id) != 0)
    {
        /*the local one only load once*/
        if (m_hms_info_jsons.count(dev_type_id) == 0) {
 
            std::string load_version;
            load_from_local(QUERY_HMS_INFO, dev_type_id, &m_hms_info_jsons[dev_type_id], load_version);/*load from local first*/
            if (load_version.empty() || load_version == "0") {
                copy_from_data_dir_to_local(); // STUDIO-9512
                load_from_local(QUERY_HMS_INFO, dev_type_id, &m_hms_info_jsons[dev_type_id], load_version);/*copy files to local, and retry load*/
            }
        }
 
        if (m_hms_action_jsons.count(dev_type_id) == 0) {
            std::string load_version;
            load_from_local(QUERY_HMS_ACTION, dev_type_id, &m_hms_action_jsons[dev_type_id], load_version);/*load from local first*/
            if (load_version.empty() || load_version == "0") {
                copy_from_data_dir_to_local(); // STUDIO-9512
                load_from_local(QUERY_HMS_ACTION, dev_type_id, &m_hms_action_jsons[dev_type_id], load_version);/*copy files to local, and retry load*/
            }
        }
    }
 
    /*download from cloud*/
    time_t info_last_update_time = m_cloud_hms_last_update_time[dev_type_id];
 
    /* check hms is valid or not */
    bool retry = false;
    if(m_hms_info_jsons[dev_type_id].empty() || m_hms_action_jsons[dev_type_id].empty()){
        retry =time(nullptr) - info_last_update_time > (60 * 1); // retry after 1 minute
    }
 
    if (time(nullptr) - info_last_update_time > (60 * 60 * 24) || retry)/*do not update in one day to reduce waiting*/
    {
        download_hms_related(QUERY_HMS_INFO, dev_type_id, &m_hms_info_jsons[dev_type_id]);
        download_hms_related(QUERY_HMS_ACTION, dev_type_id, &m_hms_action_jsons[dev_type_id]);
        m_cloud_hms_last_update_time[dev_type_id] = time(nullptr);
    }
}

References copy_from_data_dir_to_local(), download_hms_related(), Slic3r::empty(), load_from_local(), m_cloud_hms_last_update_time, m_hms_action_jsons, m_hms_info_jsons, m_hms_mutex, package_dev_id_types, QUERY_HMS_ACTION, and QUERY_HMS_INFO.

Referenced by _is_internal_error(), _query_error_image_action(), _query_error_msg(), and _query_hms_msg().

Here is the call graph for this function:

Here is the caller graph for this function:

is_internal_error()

bool Slic3r::GUI::HMSQuery::is_internal_error	(	const MachineObject *	obj,
		int	print_error )

{
    char buf[32];
    ::sprintf(buf, "%08X", print_error);
    std::string lang_code = HMSQuery::hms_language_code();
    return _is_internal_error(get_dev_id_type(obj), std::string(buf), lang_code);
}

References _is_internal_error(), get_dev_id_type(), and hms_language_code().

Here is the call graph for this function:

load_from_local()

int Slic3r::GUI::HMSQuery::load_from_local ( const std::string & hms_type, const std::string & dev_id_type, nlohmann::json * receive_json, std::string & version_info )

private

{
    if (data_dir().empty()) {
        load_version = "0";
        BOOST_LOG_TRIVIAL(error) << "HMS: load_from_local, data_dir() is empty";
        return -1;
    }
    std::string filename = get_hms_file(hms_type, HMSQuery::hms_language_code(), dev_id_type);
    auto hms_folder = (boost::filesystem::path(data_dir()) / "hms");
    if (!fs::exists(hms_folder))
        fs::create_directory(hms_folder);
 
    std::string dir_str = (hms_folder / filename).make_preferred().string();
    std::ifstream json_file(encode_path(dir_str.c_str()));
    try {
        if (json_file.is_open())
        {
            const json &j = json::parse(json_file);
            if (hms_type.compare(QUERY_HMS_INFO) == 0) {
                if (j.contains("data")) { (*load_json) = j["data"]; }
            } else if (hms_type.compare(QUERY_HMS_ACTION) == 0) {
                if (j.contains("data")) { (*load_json)["data"] = j["data"]; }
            }
 
            if (j.contains("version")) {
                load_version = DevJsonValParser::get_longlong_val(j["version"]);
            }
            else if (j.contains("ver")) {
                load_version = DevJsonValParser::get_longlong_val(j["ver"]);
            }
            else
            {
                BOOST_LOG_TRIVIAL(warning) << "HMS: load_from_local, no version info";
            }
 
            return 0;
        }
    } catch(...) {
        load_version = "0";
        BOOST_LOG_TRIVIAL(error) << "HMS: load_from_local failed";
        return -1;
    }
    load_version = "0";
    return 0;
}

References Slic3r::data_dir(), Slic3r::empty(), Slic3r::encode_path(), get_hms_file(), Slic3r::DevJsonValParser::get_longlong_val(), hms_language_code(), QUERY_HMS_ACTION, and QUERY_HMS_INFO.

Referenced by download_hms_related(), and init_hms_info().

Here is the call graph for this function:

Here is the caller graph for this function:

query_hms_msg() [1/2]

wxString Slic3r::GUI::HMSQuery::query_hms_msg	(	const MachineObject *	obj,
		const std::string &	long_error_code )

{
    if (!obj)
    {
        return wxEmptyString;
    }
 
    AppConfig* config = wxGetApp().app_config;
    if (!config) return wxEmptyString;
    const std::string& lang_code = HMSQuery::hms_language_code();
    return _query_hms_msg(get_dev_id_type(obj),long_error_code, lang_code);
}

References _query_hms_msg(), get_dev_id_type(), and hms_language_code().

Here is the call graph for this function:

query_hms_msg() [2/2]

wxString Slic3r::GUI::HMSQuery::query_hms_msg	(	const std::string &	dev_id,
		const std::string &	long_error_code )

{
    AppConfig* config = wxGetApp().app_config;
    if (!config) return wxEmptyString;
    const std::string& lang_code = HMSQuery::hms_language_code();
    return _query_hms_msg(dev_id.substr(0, 3), long_error_code, lang_code);
}

References _query_hms_msg(), and hms_language_code().

Here is the call graph for this function:

query_image_from_local()

wxImage Slic3r::GUI::HMSQuery::query_image_from_local

(

const wxString &

image_name

)

{
    if (image_name.empty() || image_name.Contains("http"))
    {
        return wxImage();
    }
 
    if (m_hms_local_images.empty())
    {
        const fs::path& local_img_dir = fs::path(Slic3r::data_dir()) / HMS_LOCAL_IMG_PATH;
        if (fs::exists(local_img_dir))
        {
            for (const auto &entry : fs::directory_iterator(local_img_dir))
            {
                const fs::path& image_path = entry.path();
                const fs::path& image_name = fs::relative(image_path, local_img_dir);
                // Orca: from_path() for correct UTF-8 path encoding
                m_hms_local_images[from_path(image_name)] = wxImage(from_path(image_path));
            }
        }
    }
 
    auto iter = m_hms_local_images.find(image_name);
    if (iter != m_hms_local_images.end())
    {
        return iter->second;
    }
 
    return wxImage();
}

References Slic3r::data_dir(), Slic3r::GUI::from_path(), HMS_LOCAL_IMG_PATH, and m_hms_local_images.

Here is the call graph for this function:

query_print_error_msg() [1/2]

wxString Slic3r::GUI::HMSQuery::query_print_error_msg	(	const MachineObject *	obj,
		int	print_error )

{
    if (!obj)
    {
        return wxEmptyString;
    }
 
    char buf[32];
    ::sprintf(buf, "%08X", print_error);
    std::string lang_code = HMSQuery::hms_language_code();
    return _query_error_msg(get_dev_id_type(obj), std::string(buf), lang_code);
}

References _query_error_msg(), get_dev_id_type(), and hms_language_code().

Here is the call graph for this function:

query_print_error_msg() [2/2]

wxString Slic3r::GUI::HMSQuery::query_print_error_msg	(	const std::string &	dev_id,
		int	print_error )

{
    char buf[32];
    ::sprintf(buf, "%08X", print_error);
    std::string lang_code = HMSQuery::hms_language_code();
    return _query_error_msg(dev_id.substr(0, 3), std::string(buf), lang_code);
}

References _query_error_msg(), and hms_language_code().

Here is the call graph for this function:

query_print_image_action()

wxString Slic3r::GUI::HMSQuery::query_print_image_action	(	const MachineObject *	obj,
		int	print_error,
		std::vector< int > &	button_action )

{
    if (!obj)
    {
        return wxEmptyString;
    }
 
    char buf[32];
    ::sprintf(buf, "%08X", print_error);
    //The first three digits of SN number
    const auto result = _query_error_image_action(get_dev_id_type(obj),std::string(buf), button_action);
    if (should_disable_hms() && result.Contains("http")) {
        return wxEmptyString;
    }
    return result;
}

References _query_error_image_action(), get_dev_id_type(), and should_disable_hms().

Here is the call graph for this function:

save_to_local()

int Slic3r::GUI::HMSQuery::save_to_local ( std::string lang, std::string hms_type, std::string dev_id_type, nlohmann::json save_json )

private

{
    if (data_dir().empty()) {
        BOOST_LOG_TRIVIAL(error) << "HMS: save_to_local, data_dir() is empty";
        return -1;
    }
    std::string filename = get_hms_file(hms_type,lang, dev_id_type);
    auto hms_folder = (boost::filesystem::path(data_dir()) / "hms");
    if (!fs::exists(hms_folder))
        fs::create_directory(hms_folder);
    std::string dir_str = (hms_folder / filename).make_preferred().string();
    std::ofstream json_file(encode_path(dir_str.c_str()));
    if (json_file.is_open()) {
        json_file << save_json.dump(1, '\t') << std::endl; // Orca: tab-indented dump
        json_file.close();
        return 0;
    }
    BOOST_LOG_TRIVIAL(error) << "HMS: save_to_local failed";
    return -1;
}

References Slic3r::data_dir(), Slic3r::empty(), Slic3r::encode_path(), and get_hms_file().

Referenced by download_hms_related().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_cloud_hms_last_update_time

std::unordered_map<std::string, std::time_t> Slic3r::GUI::HMSQuery::m_cloud_hms_last_update_time

protected

Referenced by clear_hms_info(), and init_hms_info().

m_hms_action_jsons

std::unordered_map<std::string, nlohmann::json> Slic3r::GUI::HMSQuery::m_hms_action_jsons

protected

Referenced by _query_error_image_action(), clear_hms_info(), and init_hms_info().

m_hms_info_jsons

std::unordered_map<std::string, nlohmann::json> Slic3r::GUI::HMSQuery::m_hms_info_jsons

protected

Referenced by _is_internal_error(), _query_error_msg(), _query_hms_msg(), clear_hms_info(), and init_hms_info().

m_hms_local_images

std::unordered_map<wxString, wxImage> Slic3r::GUI::HMSQuery::m_hms_local_images

protected

Referenced by query_image_from_local().

m_hms_mutex

std::mutex Slic3r::GUI::HMSQuery::m_hms_mutex

mutableprotected

Referenced by clear_hms_info(), and init_hms_info().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/HMS.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/HMS.cpp