Slic3r::OrcaCloudServiceAgent Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/OrcaCloudServiceAgent.hpp>

Inheritance diagram for Slic3r::OrcaCloudServiceAgent:

Collaboration diagram for Slic3r::OrcaCloudServiceAgent:

Classes
struct	SessionInfo
struct	PkceBundle
struct	HttpResult

Public Types
using	SessionHandler = std::function<bool(const std::string&)>
using	OnLoginCompleteHandler = std::function<void(bool success, const std::string& user_id)>

Public Member Functions
	OrcaCloudServiceAgent (std::string log_dir)
	~OrcaCloudServiceAgent () override
std::string	get_id () const override
void	configure_urls (AppConfig *app_config)
void	set_api_base_url (const std::string &url)
void	set_auth_base_url (const std::string &url)
void	set_cloud_base_url (const std::string &url)
std::string	get_cloud_base_url () const
void	set_use_encrypted_token_file (bool use)
bool	get_use_encrypted_token_file () const
int	init_log () override
int	set_config_dir (std::string config_dir) override
int	set_cert_file (std::string folder, std::string filename) override
int	set_country_code (std::string country_code) override
int	start () override
int	change_user (std::string user_info) override
bool	is_user_login () override
int	user_logout (bool request=false) override
std::string	get_user_id () override
std::string	get_user_name () override
std::string	get_user_avatar () override
std::string	get_user_nickname () override
std::string	build_login_cmd () override
std::string	build_logout_cmd () override
std::string	build_login_info () override
std::string	get_access_token () const override
std::string	get_refresh_token () const override
bool	ensure_token_fresh (const std::string &reason) override
std::string	get_cloud_service_host () override
std::string	get_cloud_login_url (const std::string &language="") override
std::string	build_web_session_start_url (const std::string &next=std::string()) const
std::string	build_web_session_complete_url (const std::string &token_hash, const std::string &state) const
std::string	build_web_session_signout_url () const
int	request_web_session_handoff (std::string &token_hash, std::string &error_code, unsigned int &http_code)
int	connect_server () override
bool	is_server_connected () override
int	refresh_connection () override
void	stop_health_check ()
bool	is_refresh_running () const
int	start_subscribe (std::string module) override
int	stop_subscribe (std::string module) override
int	add_subscribe (std::vector< std::string > dev_list) override
int	del_subscribe (std::vector< std::string > dev_list) override
void	enable_multi_machine (bool enable) override
int	get_user_presets (std::map< std::string, std::map< std::string, std::string > > *user_presets) override
std::string	request_setting_id (std::string name, std::map< std::string, std::string > *values_map, unsigned int *http_code) override
int	put_setting (std::string setting_id, std::string name, std::map< std::string, std::string > *values_map, unsigned int *http_code, bool force=false) override
SyncPushResult	sync_push (const std::string &profile_id, const std::string &name, const nlohmann::json &content, const std::string &original_updated_time="", bool force=false)
int	get_setting_list (std::string bundle_version, ProgressFn pro_fn=nullptr, WasCancelledFn cancel_fn=nullptr) override
int	get_setting_list2 (std::string bundle_version, CheckFn chk_fn, ProgressFn pro_fn=nullptr, WasCancelledFn cancel_fn=nullptr) override
int	delete_setting (std::string setting_id) override
int	get_my_message (int type, int after, int limit, unsigned int *http_code, std::string *http_body) override
int	check_user_task_report (int *task_id, bool *printable) override
int	get_user_print_info (unsigned int *http_code, std::string *http_body) override
int	get_user_tasks (TaskQueryParams params, std::string *http_body) override
int	get_printer_firmware (std::string dev_id, unsigned *http_code, std::string *http_body) override
int	get_task_plate_index (std::string task_id, int *plate_index) override
int	get_user_info (int *identifier) override
int	get_subtask_info (std::string subtask_id, std::string *task_json, unsigned int *http_code, std::string *http_body) override
int	get_slice_info (std::string project_id, std::string profile_id, int plate_index, std::string *slice_json) override
int	query_bind_status (std::vector< std::string > query_list, unsigned int *http_code, std::string *http_body) override
int	modify_printer_name (std::string dev_id, std::string dev_name) override
int	get_camera_url (std::string dev_id, std::function< void(std::string)> callback) override
int	get_design_staffpick (int offset, int limit, std::function< void(std::string)> callback) override
int	start_publish (PublishParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, std::string *out) override
int	get_model_publish_url (std::string *url) override
int	get_subtask (BBLModelTask *task, OnGetSubTaskFn getsub_fn) override
int	get_model_mall_home_url (std::string *url) override
int	get_model_mall_detail_url (std::string *url, std::string id) override
int	get_my_profile (std::string token, unsigned int *http_code, std::string *http_body) override
int	get_my_token (std::string ticket, unsigned int *http_code, std::string *http_body) override
int	track_enable (bool enable) override
int	track_remove_files () override
int	track_event (std::string evt_key, std::string content) override
int	track_header (std::string header) override
int	track_update_property (std::string name, std::string value, std::string type="string") override
int	track_get_property (std::string name, std::string &value, std::string type="string") override
bool	get_track_enable () override
int	put_model_mall_rating (int design_id, int score, std::string content, std::vector< std::string > images, unsigned int &http_code, std::string &http_error) override
int	get_oss_config (std::string &config, std::string country_code, unsigned int &http_code, std::string &http_error) override
int	put_rating_picture_oss (std::string &config, std::string &pic_oss_path, std::string model_id, int profile_id, unsigned int &http_code, std::string &http_error) override
int	get_model_mall_rating_result (int job_id, std::string &rating_result, unsigned int &http_code, std::string &http_error) override
int	get_mw_user_preference (std::function< void(std::string)> callback) override
int	get_mw_user_4ulist (int seed, int limit, std::function< void(std::string)> callback) override
std::string	get_version () override
int	set_on_server_connected_fn (AppOnServerConnectedFn fn) override
int	set_on_http_error_fn (AppOnHttpErrorFn fn) override
int	set_get_country_code_fn (GetCountryCodeFn fn) override
int	set_queue_on_main_fn (QueueOnMainFn fn) override
void	load_sync_state ()
void	save_sync_state ()
void	clear_sync_state ()
const SyncState &	get_sync_state () const
bool	unsubscribe_bundle (const std::string &bundle_id)
std::string	get_bundle_url (const std::string &bundle_id) const
int	get_subscribed_bundles (std::vector< std::pair< std::string, std::string > > *bundles, std::vector< std::string > &notfound, std::vector< std::string > &unauthorized)
int	get_shared_bundle (const std::string &bundle_id, std::map< std::string, std::map< std::string, std::string > > *presets, BundleMetadata *bundle_metadata)
int	fetch_subscribed_manifests_into_descriptors (std::vector< PluginDescriptor > &descriptors, std::vector< std::string > &not_found, std::vector< std::string > &unauthorized)
int	fetch_mine_manifests_into_descriptors (std::vector< PluginDescriptor > &descriptors)
int	get_plugin_download_url (const std::string &uuid, const std::string &requested_version, std::vector< PluginDownloadData > &data, std::vector< PluginDownloadNotFound > &not_found, std::vector< std::string > &unauthorized)
std::string	get_plugin_url (const std::string &sharing_token) const
int	subscribe_plugin (const std::string &plugin_uuid)
int	unsubscribe_plugins (const std::vector< std::string > &plugin_uuids)
int	fetch_plugin_changelogs (const std::vector< std::string > &uuids, std::unordered_map< std::string, std::vector< PluginChangelog > > &changelog)
void	set_session_handler (SessionHandler handler)
void	set_on_login_complete_handler (OnLoginCompleteHandler handler)
const PkceBundle &	pkce ()
void	regenerate_pkce ()
void	persist_user_secret (const std::string &secret)
bool	load_user_secret (std::string &out_secret)
void	clear_user_secret (bool all_backends=false)
bool	refresh_if_expiring (std::chrono::seconds skew, const std::string &reason)
RefreshResult	refresh_from_storage (const std::string &reason, bool async=false)
RefreshResult	refresh_now (const std::string &refresh_token, const std::string &reason, bool async=false)
RefreshResult	refresh_session_with_token (const std::string &refresh_token, const std::string &reason="")
bool	set_user_session (const std::string &token, const std::string &user_id, const std::string &username, const std::string &nickname, const std::string &avatar, const std::string &refresh_token="", bool persist=true)
bool	set_user_session (const nlohmann::json &session_json, bool notify_login=true)
void	clear_session (bool all_backends=false)
virtual std::unique_ptr< ICameraSignalingChannel >	create_camera_signaling_channel (const std::string &dev_id)

Static Public Member Functions
static std::string	generate_uuid_for_setting_id (const std::string &name, const std::string &user_id="")

Private Member Functions
int	sync_pull (std::function< void(const SyncPullResponse &)> on_success, std::function< void(int http_code, const std::string &error)> on_error)
bool	resolve_unauthorized (HttpResult &res, const std::function< HttpResult()> &perform, const std::string &reason)
int	http_get (const std::string &path, std::string *response_body, unsigned int *http_code)
int	http_post (const std::string &path, const std::string &body, std::string *response_body, unsigned int *http_code)
int	http_put (const std::string &path, const std::string &body, std::string *response_body, unsigned int *http_code)
int	http_delete (const std::string &path, std::string *response_body, unsigned int *http_code)
std::map< std::string, std::string >	data_headers ()
RefreshResult	attempt_refresh_after_unauthorized (const std::string &reason)
bool	http_post_token (const std::string &body, std::string *response_body, unsigned int *http_code, const std::string &url="")
bool	http_post_auth (const std::string &path, const std::string &body, std::string *response_body, unsigned int *http_code)
bool	exchange_auth_code (const std::string &auth_code, const std::string &state, std::string &session_payload)
void	update_redirect_uri ()
void	compute_fallback_path ()
bool	decode_jwt_expiry (const std::string &token, std::chrono::system_clock::time_point &out_tp)
bool	should_refresh_locked (std::chrono::seconds skew) const
bool	run_health_check (const std::atomic_bool *cancel)
void	invoke_server_connected_callback (int return_code, int reason_code)
void	invoke_http_error_callback (unsigned http_code, const std::string &http_body)
std::string	map_to_json (const std::map< std::string, std::string > &map)
void	json_to_map (const std::string &json, std::map< std::string, std::string > &map)
std::string	token_lock_path () const

Private Attributes
std::string	log_dir
std::string	config_dir
std::string	api_base_url
std::string	auth_base_url
std::string	cloud_base_url
std::string	country_code
std::map< std::string, std::string >	extra_headers
std::map< std::string, std::string >	auth_headers
std::mutex	headers_mutex
bool	m_use_encrypted_token_file {false}
PkceBundle	pkce_bundle
std::string	secret_fallback_path
std::atomic_bool	secret_stored {false}
SessionHandler	session_handler
OnLoginCompleteHandler	on_login_complete_handler
SessionInfo	session
std::mutex	session_mutex
std::atomic< long long >	last_refresh_success_epoch {0}
const long long	agent_start_epoch
bool	is_connected {false}
bool	enable_track {false}
bool	multi_machine_enabled {false}
SyncState	sync_state
std::string	sync_state_path
AppOnServerConnectedFn	on_server_connected_fn
AppOnHttpErrorFn	on_http_error_fn
GetCountryCodeFn	get_country_code_fn
QueueOnMainFn	queue_on_main_fn
std::mutex	callback_mutex
std::recursive_mutex	state_mutex
std::thread	refresh_thread
std::atomic_bool	refresh_running {false}
std::thread	health_check_thread
std::atomic_bool	health_check_running {false}
std::atomic_bool	health_check_stopped {false}

Detailed Description

OrcaCloudServiceAgent - Native cloud service and authentication implementation for Orca Cloud.

Implements the ICloudServiceAgent interface with:

• Full OAuth 2.0 PKCE authentication support
• Token storage via wxSecretStore with AES-256-GCM encrypted file fallback
• JWT expiry decoding and proactive token refresh
• Session management with thread-safe state access
• Settings synchronization (sync_pull, sync_push)
• Server connectivity management
• HTTP helpers with automatic token injection

This class combines the functionality of the former OrcaAuthAgent and OrcaCloudServiceAgent.

---

Class Documentation

Slic3r::OrcaCloudServiceAgent::SessionInfo

struct Slic3r::OrcaCloudServiceAgent::SessionInfo

Collaboration diagram for Slic3r::OrcaCloudServiceAgent::SessionInfo:

Class Members
string	access_token
time_point	expires_at {}
bool	logged_in = false
string	refresh_token
string	user_avatar
string	user_id
string	user_name
string	user_nickname

Slic3r::OrcaCloudServiceAgent::PkceBundle

struct Slic3r::OrcaCloudServiceAgent::PkceBundle

Collaboration diagram for Slic3r::OrcaCloudServiceAgent::PkceBundle:

Class Members
string	challenge
int	loopback_port = auth_constants::LOOPBACK_PORT
string	redirect
string	state
string	verifier

Slic3r::OrcaCloudServiceAgent::HttpResult

struct Slic3r::OrcaCloudServiceAgent::HttpResult

Collaboration diagram for Slic3r::OrcaCloudServiceAgent::HttpResult:

Class Members
string	body
unsigned int	status {0}
bool	success {false}

Member Typedef Documentation

OnLoginCompleteHandler

using Slic3r::OrcaCloudServiceAgent::OnLoginCompleteHandler = std::function<void(bool success, const std::string& user_id)>

SessionHandler

using Slic3r::OrcaCloudServiceAgent::SessionHandler = std::function<bool(const std::string&)>

Constructor & Destructor Documentation

OrcaCloudServiceAgent()

Slic3r::OrcaCloudServiceAgent::OrcaCloudServiceAgent ( std::string log_dir )

explicit

    : log_dir(std::move(log_dir))
    , api_base_url(ORCA_DEFAULT_API_URL)
    , auth_base_url(ORCA_DEFAULT_AUTH_URL)
    , cloud_base_url(ORCA_DEFAULT_CLOUD_URL)
{
    auth_headers["apikey"]    = ORCA_DEFAULT_PUB_KEY;
    pkce_bundle.loopback_port = choose_loopback_port();
    update_redirect_uri();
    regenerate_pkce();
    compute_fallback_path();
}

References api_base_url, auth_base_url, auth_headers, cloud_base_url, compute_fallback_path(), log_dir, pkce_bundle, regenerate_pkce(), and update_redirect_uri().

Here is the call graph for this function:

~OrcaCloudServiceAgent()

Slic3r::OrcaCloudServiceAgent::~OrcaCloudServiceAgent ( )

override

{
    stop_health_check();
    if (refresh_thread.joinable()) {
        refresh_thread.join();
    }
}

References refresh_thread, and stop_health_check().

Here is the call graph for this function:

Member Function Documentation

add_subscribe()

int Slic3r::OrcaCloudServiceAgent::add_subscribe ( std::vector< std::string > dev_list )

overridevirtual

Subscribe to push streams for specific device identifiers.

Implements Slic3r::ICloudServiceAgent.

{
    (void) dev_list;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

attempt_refresh_after_unauthorized()

RefreshResult Slic3r::OrcaCloudServiceAgent::attempt_refresh_after_unauthorized ( const std::string & reason )

private

{
    RefreshResult r = refresh_from_storage(reason, false);
    if (r != RefreshResult::Transient) return r;  // Success or AuthRejected: decided, no retry
 
    // Only a transient (network/server) failure is worth retrying.
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    r = refresh_from_storage(reason + "_retry", false);
 
    if (r == RefreshResult::Transient)
        BOOST_LOG_TRIVIAL(warning) << "[auth] event=refresh result=transient source=" << reason << " action=keep_session";
    else if (r == RefreshResult::AuthRejected)
        BOOST_LOG_TRIVIAL(warning) << "[auth] event=refresh result=rejected source=" << reason << " action=logout";
    return r;
}

References Slic3r::AuthRejected, refresh_from_storage(), and Slic3r::Transient.

Referenced by resolve_unauthorized().

Here is the call graph for this function:

Here is the caller graph for this function:

build_login_cmd()

std::string Slic3r::OrcaCloudServiceAgent::build_login_cmd ( )

overridevirtual

Build a JSON command for the WebView login flow. Contains backend URL, API key, and PKCE parameters.

Implements Slic3r::ICloudServiceAgent.

{
    // When already signed in, emit the homepage payload so the web UI
    // can flip to the logged-in state without re-opening the login flow.
    if (is_user_login()) {
        std::string display_name = get_user_nickname();
        if (display_name.empty()) {
            display_name = _u8L("unknown name");
        }
        json cmd;
        cmd["command"]         = "orca_userlogin";
        cmd["data"]["name"]    = display_name;
        cmd["data"]["avatar"]  = get_user_avatar();
        // The unique handle, shown under the display name in the homepage account menu.
        cmd["data"]["account"] = get_user_name();
        return cmd.dump();
    }
 
    update_redirect_uri();
    regenerate_pkce();
    const auto bundle = pkce();
 
    json tree;
    tree["action"]      = "login_config";
    tree["backend_url"] = auth_base_url;
 
    // Include API key for direct Supabase calls from JavaScript
    {
        std::lock_guard<std::recursive_mutex> lock(state_mutex);
        auto it = auth_headers.find("apikey");
        if (it != auth_headers.end()) {
            tree["apikey"] = it->second;
        }
    }
 
    tree["pkce"]["code_challenge"]        = bundle.challenge;
    tree["pkce"]["code_challenge_method"] = "S256";
    tree["pkce"]["state"]                 = bundle.state;
    tree["pkce"]["redirect_uri"]          = bundle.redirect;
    tree["pkce"]["code_verifier"]         = bundle.verifier;
    tree["pkce"]["loopback_port"]         = bundle.loopback_port;
 
    return tree.dump();
}

References _u8L, auth_base_url, auth_headers, get_user_avatar(), get_user_name(), get_user_nickname(), is_user_login(), pkce(), regenerate_pkce(), state_mutex, and update_redirect_uri().

Here is the call graph for this function:

build_login_info()

std::string Slic3r::OrcaCloudServiceAgent::build_login_info ( )

overridevirtual

Return a JSON snapshot of the active session (user info, no tokens). Used by WebView to display current user state.

Implements Slic3r::ICloudServiceAgent.

{
    json tree;
    {
        std::lock_guard<std::mutex> lock(session_mutex);
        tree["user_id"]   = session.user_id;
        tree["user_name"] = session.user_name;
        tree["nickname"]  = session.user_nickname;
        tree["avatar"]    = session.user_avatar;
        tree["logged_in"] = session.logged_in;
    }
    // Do not expose tokens to the WebView
    tree["access_token"]  = "";
    tree["refresh_token"] = "";
    tree["backend_url"]   = api_base_url;
    tree["auth_url"]      = auth_base_url;
 
    return tree.dump();
}

References api_base_url, auth_base_url, session, and session_mutex.

build_logout_cmd()

std::string Slic3r::OrcaCloudServiceAgent::build_logout_cmd ( )

overridevirtual

Build a JSON command for WebView logout.

Implements Slic3r::ICloudServiceAgent.

{ return json{{"command", "orca_useroffline"}}.dump(); }

build_web_session_complete_url()

std::string Slic3r::OrcaCloudServiceAgent::build_web_session_complete_url	(	const std::string &	token_hash,
		const std::string &	state ) const

{
    if (cloud_base_url.empty() || token_hash.empty() || state.empty())
        return "";
 
    // Fragment (not query) so the one-time token never reaches a server or a log.
    return cloud_base_url + "/auth/handoff#token_hash=" + percent_encode_unreserved(token_hash) +
           "&state=" + percent_encode_unreserved(state);
}

References cloud_base_url, and Slic3r::percent_encode_unreserved().

Here is the call graph for this function:

build_web_session_signout_url()

std::string Slic3r::OrcaCloudServiceAgent::build_web_session_signout_url

(

)

const

{
    if (cloud_base_url.empty())
        return "";
    return cloud_base_url + "/auth/handoff?signout=1";
}

References cloud_base_url.

build_web_session_start_url()

std::string Slic3r::OrcaCloudServiceAgent::build_web_session_start_url

(

const std::string &

next = std::string()

)

const

{
    if (cloud_base_url.empty())
        return "";
 
    // The page replaces a `next` that is not a same-site path with /app/profiles, so pass a
    // same-site path (the guide's default) and let it validate.
    std::string url = cloud_base_url + "/auth/handoff?next=" +
                      percent_encode_unreserved(next.empty() ? "/app/profiles" : next);
 
    std::lock_guard<std::mutex> lock(session_mutex);
    if (session.logged_in && !session.user_id.empty())
        url += "&user_id=" + percent_encode_unreserved(session.user_id);
    return url;
}

References cloud_base_url, Slic3r::percent_encode_unreserved(), session, and session_mutex.

Here is the call graph for this function:

change_user()

int Slic3r::OrcaCloudServiceAgent::change_user ( std::string user_info )

overridevirtual

Authenticate the user with the provided JSON payload.

Supported formats:

1. Traditional: {"username": "...", "password": "..."}
2. WebView/OAuth: {"command": "user_login", "data": {...}}
3. Token format: {"data": {"token": "...", "refresh_token": "...", "user": {...}}}

Implements Slic3r::ICloudServiceAgent.

{
    try {
        auto tree = json::parse(user_info);
 
        auto safe_str = [](const json& j, const std::string& key) -> std::string {
            if (j.contains(key) && j[key].is_string())
                return j[key].get<std::string>();
            return "";
        };
 
        // Check if this is a WebView login message (PKCE flow completion)
        std::string command = safe_str(tree, "command");
        if (command == "user_login") {
            if (!tree.contains("data") || !tree["data"].is_object()) {
                BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: WebView login payload missing data field";
                return BAMBU_NETWORK_ERR_INVALID_HANDLE;
            }
            const auto& data  = tree["data"];
            std::string state = safe_str(data, "state");
 
            // Check for auth code (PKCE authorization code flow)
            std::string auth_code = safe_str(data, "code");
            if (!auth_code.empty()) {
                std::string session_payload;
                if (!exchange_auth_code(auth_code, state, session_payload)) {
                    return BAMBU_NETWORK_ERR_INVALID_HANDLE;
                }
                // Recursively process the session payload (contains access_token, user, etc.)
                return change_user(session_payload);
            }
 
            // Validate PKCE state
            const auto expected_state = pkce_bundle.state;
            if (!expected_state.empty() && state != expected_state) {
                BOOST_LOG_TRIVIAL(warning) << "[auth] event=login result=failure reason=state_mismatch";
                return BAMBU_NETWORK_ERR_INVALID_HANDLE;
            }
 
            // Direct token flow (tokens already obtained by WebView)
            bool success = set_user_session(data);
            BOOST_LOG_TRIVIAL(info) << "[auth] event=login result=" << (success ? "success" : "failure") << " source=webview";
            return success ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_INVALID_HANDLE;
        }
 
        // Orca cloud session payload (default flow)
        const json* session_node = nullptr;
        if (tree.contains("data") && tree["data"].is_object()) {
            const auto& data = tree["data"];
            if (data.contains("session") && data["session"].is_object()) {
                session_node = &data["session"];
            } else if (data.contains("access_token") || data.contains("token")) {
                session_node = &data;
            }
        }
        if (!session_node) {
            if (tree.contains("session") && tree["session"].is_object()) {
                session_node = &tree["session"];
            } else if (tree.contains("access_token") || tree.contains("token")) {
                session_node = &tree;
            }
        }
 
        if (session_node) {
            return set_user_session(*session_node) ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_INVALID_HANDLE;
        }
 
        BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: Username/password login is disabled. Use the Orca cloud PKCE flow.";
        return BAMBU_NETWORK_ERR_INVALID_HANDLE;
 
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: change_user exception - " << e.what();
        return BAMBU_NETWORK_ERR_INVALID_RESULT;
    }
}

References BAMBU_NETWORK_ERR_INVALID_HANDLE, BAMBU_NETWORK_ERR_INVALID_RESULT, BAMBU_NETWORK_SUCCESS, change_user(), exchange_auth_code(), pkce_bundle, and set_user_session().

Referenced by change_user().

Here is the call graph for this function:

Here is the caller graph for this function:

check_user_task_report()

int Slic3r::OrcaCloudServiceAgent::check_user_task_report ( int * task_id, bool * printable )

overridevirtual

Check for pending task reports.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: check_user_task_report (stub)";
    if (task_id)
        *task_id = 0;
    if (printable)
        *printable = false;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

clear_session()

void Slic3r::OrcaCloudServiceAgent::clear_session

(

bool

all_backends = false

)

{
    {
        std::lock_guard<std::mutex> lock(session_mutex);
        session = SessionInfo{};
    }
    clear_user_secret(all_backends);
}

References clear_user_secret(), session, and session_mutex.

Referenced by user_logout().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_sync_state()

void Slic3r::OrcaCloudServiceAgent::clear_sync_state

(

)

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    sync_state = SyncState{};
    if (!sync_state_path.empty() && boost::filesystem::exists(sync_state_path)) {
        boost::filesystem::remove(sync_state_path);
    }
}

References state_mutex, sync_state, and sync_state_path.

Referenced by sync_pull().

Here is the caller graph for this function:

clear_user_secret()

void Slic3r::OrcaCloudServiceAgent::clear_user_secret

(

bool

all_backends = false

)

{
    // Nothing this process loaded or saved: leave the store alone. Deleting would only cost a
    // keychain round trip (or a hang while the keychain is unresponsive) and could remove a
    // login another instance just saved.
    if (!secret_stored.exchange(false) && !all_backends) {
        return;
    }
 
    if (all_backends || !m_use_encrypted_token_file) {
        wxSecretStore store = wxSecretStore::GetDefault();
        if (store.IsOk()) {
            store.Delete(SECRET_STORE_SERVICE);
        }
    }
 
    compute_fallback_path();
    if (!secret_fallback_path.empty() && wxFileExists(wxString::FromUTF8(secret_fallback_path.c_str()))) {
        wxRemoveFile(wxString::FromUTF8(secret_fallback_path.c_str()));
    }
}

References compute_fallback_path(), m_use_encrypted_token_file, secret_fallback_path, and secret_stored.

Referenced by clear_session(), and persist_user_secret().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_fallback_path()

void Slic3r::OrcaCloudServiceAgent::compute_fallback_path ( )

private

{
    if (!secret_fallback_path.empty())
        return;
    // wxStandardPaths::GetUserDataDir() resolves the app data directory via
    // wxAppConsoleBase::GetAppName(), which dereferences wxTheApp. In headless
    // contexts (CLI, unit tests) there is no wxApp, so guard the call to avoid a
    // null dereference. The path can still be provided explicitly through
    // set_config_dir(); when it is left empty, file persistence is skipped.
    if (wxTheApp == nullptr)
        return;
    wxFileName fallback(wxStandardPaths::Get().GetUserDataDir(), "orca_refresh_token.sec");
    fallback.MakeAbsolute();
    secret_fallback_path = fallback.GetFullPath().ToStdString();
}

References secret_fallback_path.

Referenced by OrcaCloudServiceAgent(), clear_user_secret(), load_user_secret(), and persist_user_secret().

Here is the caller graph for this function:

configure_urls()

void Slic3r::OrcaCloudServiceAgent::configure_urls

(

AppConfig *

app_config

)

{
    if (!app_config)
        return;
 
    // Read token storage preference
    m_use_encrypted_token_file = app_config->get_bool(SETTING_USE_ENCRYPTED_TOKEN_FILE);
 
    std::string api_url = app_config->get(CONFIG_ORCA_API_URL);
    if (!api_url.empty()) {
        api_base_url = api_url;
    }
 
    std::string auth_url = app_config->get(CONFIG_ORCA_AUTH_URL);
    if (!auth_url.empty()) {
        auth_base_url = auth_url;
    }
 
    std::string cloud_url = app_config->get(CONFIG_ORCA_CLOUD_URL);
    if (!cloud_url.empty()) {
        cloud_base_url = cloud_url;
    }
 
    std::string pub_key = app_config->get(CONFIG_ORCA_PUB_KEY);
    if (!pub_key.empty()) {
        auth_headers["apikey"] = pub_key;
    }
}

References api_base_url, auth_base_url, auth_headers, cloud_base_url, Slic3r::AppConfig::get(), Slic3r::AppConfig::get_bool(), m_use_encrypted_token_file, and SETTING_USE_ENCRYPTED_TOKEN_FILE.

Here is the call graph for this function:

connect_server()

int Slic3r::OrcaCloudServiceAgent::connect_server ( )

overridevirtual

Perform a health check against the configured backend. Updates is_server_connected() state and triggers OnServerConnectedFn.

Implements Slic3r::ICloudServiceAgent.

{
    return run_health_check(nullptr) ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_CONNECTION_TO_SERVER_FAILED;
}

References BAMBU_NETWORK_ERR_CONNECTION_TO_SERVER_FAILED, BAMBU_NETWORK_SUCCESS, and run_health_check().

Here is the call graph for this function:

create_camera_signaling_channel()

virtual std::unique_ptr< ICameraSignalingChannel > Slic3r::ICloudServiceAgent::create_camera_signaling_channel ( const std::string & dev_id )

inlinevirtualinherited

Create a camera signaling channel object for P2P camera streaming over WebRTC.

    {
        (void) dev_id;
        return nullptr;
    }

data_headers()

std::map< std::string, std::string > Slic3r::OrcaCloudServiceAgent::data_headers ( )

private

{
    std::scoped_lock lock(state_mutex, headers_mutex);
    auto headers = auth_headers;
    for (const auto& pair : extra_headers) {
        headers[pair.first] = pair.second;
    }
    return headers;
}

References auth_headers, extra_headers, headers_mutex, and state_mutex.

Referenced by http_delete(), http_get(), http_post(), http_put(), request_web_session_handoff(), and run_health_check().

Here is the caller graph for this function:

decode_jwt_expiry()

bool Slic3r::OrcaCloudServiceAgent::decode_jwt_expiry ( const std::string & token, std::chrono::system_clock::time_point & out_tp )

private

{
    out_tp = {};
    if (token.empty())
        return false;
 
    auto first  = token.find('.');
    auto second = token.find('.', first == std::string::npos ? 0 : first + 1);
    if (first == std::string::npos || second == std::string::npos)
        return false;
 
    std::string payload_b64 = token.substr(first + 1, second - first - 1);
    std::vector<unsigned char> payload_bytes;
    if (!base64url_decode(payload_b64, payload_bytes))
        return false;
 
    std::string payload_str(payload_bytes.begin(), payload_bytes.end());
    try {
        auto payload = json::parse(payload_str);
        if (payload.contains("exp") && payload["exp"].is_number()) {
            out_tp = std::chrono::system_clock::time_point{std::chrono::seconds(payload["exp"].get<long long>())};
            return true;
        }
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: failed to decode JWT exp - " << e.what();
    }
    return false;
}

Referenced by set_user_session().

Here is the caller graph for this function:

del_subscribe()

int Slic3r::OrcaCloudServiceAgent::del_subscribe ( std::vector< std::string > dev_list )

overridevirtual

Remove device-level subscriptions.

Implements Slic3r::ICloudServiceAgent.

{
    (void) dev_list;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

delete_setting()

int Slic3r::OrcaCloudServiceAgent::delete_setting ( std::string setting_id )

overridevirtual

Delete a remote preset.

Implements Slic3r::ICloudServiceAgent.

{
    std::string path = std::string(ORCA_SYNC_DELETE_PATH) + "?resource=" + ORCA_SYNC_PROFILE_TABLE + "&id=" + setting_id;
    std::string response;
    unsigned int http_code = 0;
 
    int result = http_delete(path, &response, &http_code);
 
    // Treat 204 as success: the setting is already gone from cloud, which is our goal.
    if (http_code == 204) {
        return BAMBU_NETWORK_SUCCESS;
    }
 
    if (result != BAMBU_NETWORK_SUCCESS || http_code >= 400) {
        return BAMBU_NETWORK_ERR_DEL_SETTING_FAILED;
    }
 
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_ERR_DEL_SETTING_FAILED, BAMBU_NETWORK_SUCCESS, and http_delete().

Here is the call graph for this function:

enable_multi_machine()

void Slic3r::OrcaCloudServiceAgent::enable_multi_machine ( bool enable )

overridevirtual

Enable or disable multi-machine mode.

Implements Slic3r::ICloudServiceAgent.

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    multi_machine_enabled = enable;
}

References multi_machine_enabled, and state_mutex.

ensure_token_fresh()

bool Slic3r::OrcaCloudServiceAgent::ensure_token_fresh ( const std::string & reason )

overridevirtual

Ensure the access token is fresh, refreshing if necessary. Call before making API requests to avoid 401 errors.

Parameters

reason

Descriptive string for logging (e.g., "connect_server")

Returns

true if the token is fresh or was successfully refreshed

Implements Slic3r::ICloudServiceAgent.

{ return refresh_if_expiring(TOKEN_REFRESH_SKEW, reason); }

References refresh_if_expiring().

Referenced by http_delete(), http_get(), http_post(), http_put(), and request_web_session_handoff().

Here is the call graph for this function:

Here is the caller graph for this function:

exchange_auth_code()

bool Slic3r::OrcaCloudServiceAgent::exchange_auth_code ( const std::string & auth_code, const std::string & state, std::string & session_payload )

private

{
    const auto expected_state = pkce_bundle.state;
    if (expected_state.empty()) {
        BOOST_LOG_TRIVIAL(warning) << "[auth] event=code_exchange result=failure reason=no_expected_state";
        return false;
    }
    if (state != expected_state) {
        BOOST_LOG_TRIVIAL(warning) << "[auth] event=code_exchange result=failure reason=state_mismatch";
        return false;
    }
 
    std::string code_verifier;
    {
        std::lock_guard<std::recursive_mutex> lock(state_mutex);
        code_verifier = pkce_bundle.verifier;
    }
 
    // Exchange the Supabase PKCE code with the token endpoint.
    // With redirect_to, GoTrue handles Google OAuth internally and redirects to localhost
    // with a Supabase-generated auth_code (not a raw Google code). The grant_type goes
    // in the URL query string (same pattern as the refresh_token flow).
    const std::string token_url = auth_base_url + auth_constants::TOKEN_PATH + "?grant_type=pkce";
    json body_j;
    body_j["auth_code"]     = auth_code;
    body_j["code_verifier"] = code_verifier;
 
    std::string response;
    unsigned int http_code = 0;
    const bool success     = http_post_token(body_j.dump(), &response, &http_code, token_url);
 
    if (!success || http_code >= 400) {
        BOOST_LOG_TRIVIAL(error) << "[auth] event=code_exchange result=failure http_code=" << http_code << " body=" << response;
        return false;
    }
 
    session_payload = response;
    BOOST_LOG_TRIVIAL(info) << "[auth] event=code_exchange result=success";
    return true;
}

References auth_base_url, http_post_token(), pkce_bundle, state_mutex, and Slic3r::auth_constants::TOKEN_PATH.

Referenced by change_user().

Here is the call graph for this function:

Here is the caller graph for this function:

fetch_mine_manifests_into_descriptors()

int Slic3r::OrcaCloudServiceAgent::fetch_mine_manifests_into_descriptors

(

std::vector< PluginDescriptor > &

descriptors

)

{
    constexpr int PAGE_LIMIT = 100;
    constexpr int MAX_PAGES  = 1000; // safety backstop against a server that never stops paginating
 
    int current_offset = 0;
    int page_count     = 0;
 
    while (true) {
        if (++page_count > MAX_PAGES) {
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": reached max page count (" << MAX_PAGES
                                       << "), stopping pagination";
            break;
        }
 
        const std::string path = std::string(ORCA_PLUGINS_MINE) + "?limit=" + std::to_string(PAGE_LIMIT) +
                                 "&offset=" + std::to_string(current_offset) + "&include=changelog";
 
        std::string response_body;
        unsigned int http_code = 0;
 
        int result = http_get(path, &response_body, &http_code);
 
        if (result != 0 || http_code != 200) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " failed: http_code=" << http_code;
            return result != 0 ? result : http_code;
        }
 
        try {
            auto root = json::parse(response_body);
 
            if (!root.contains("data") || !root["data"].is_array()) {
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": invalid response format, missing data array";
                return -1;
            }
 
            const auto& data = root["data"];
            for (const auto& item : data) {
                PluginDescriptor descriptor;
                std::string uuid = get_json_string_field(item, "uuid");
                if (uuid.empty())
                    uuid = get_json_string_field(item, "id");
 
                descriptor.name        = sanitize_plugin_name(get_json_string_field(item, "name"));
                descriptor.plugin_key  = uuid;
                // Cloud API "description" is intentionally not parsed: descriptions come only from the
                // plugin's Python header once installed. Cloud-only rows show a "View on OrcaCloud" link.
                descriptor.author      = parse_cloud_author(item);
                descriptor.version    = get_json_string_field(item, "version");
                descriptor.latest_version = descriptor.version;
                // Cloud "type" is cosmetic (see parse_cloud_display_types); real capability_types are
                // populated only when the plugin is actually loaded. Leave them empty here.
                descriptor.display_types = parse_cloud_display_types(item);
                descriptor.entry_package = get_json_string_field(item, "entry_package");
                descriptor.sharing_token = get_json_string_field(item, "sharing_token");
                // main_image.access_url is pre-signed, so the WebView <img> can load it without the
                // Bearer token (content_url, an API path, would 401). Images only; display-only.
                if (item.contains("main_image") && item["main_image"].is_object() && cloud_media_is_image(item["main_image"]))
                    descriptor.thumbnail_url = get_json_string_field(item["main_image"], "access_url");
                if (item.contains("changelog") && item["changelog"].is_array()) {
                    for (const auto& changelog_item : item["changelog"]) {
                        if (!changelog_item.is_object())
                            continue;
 
                        PluginChangelog entry;
                        entry.changelog_id = get_json_string_field(changelog_item, "id");
                        entry.plugin_uuid  = get_json_string_field(changelog_item, "plugin_id");
                        if (entry.plugin_uuid.empty())
                            entry.plugin_uuid = uuid;
                        entry.version      = get_json_string_field(changelog_item, "version");
                        entry.changelog    = get_json_string_field(changelog_item, "changelog");
                        entry.created_time = get_json_int64_field(changelog_item, "created_time");
 
                        descriptor.changelog.push_back(std::move(entry));
                    }
                    sort_plugin_changelog(descriptor.changelog);
                }
 
                descriptor.cloud = std::make_optional<CloudPluginState>({
                    uuid,
                    false,
                    false,
                    false,
                    true
                });
 
                descriptors.push_back(std::move(descriptor));
            }
 
            // A short (or empty) page means there is nothing left to page through. This is the
            // primary guard against a server that keeps echoing a non-null next_offset forever.
            if (data.size() < static_cast<size_t>(PAGE_LIMIT))
                break;
 
            // Honor an explicit end-of-pagination signal from the server.
            if (!root.contains("next_offset") || root["next_offset"].is_null())
                break;
 
            // Require the offset to strictly advance; otherwise a stuck/regressing offset
            // would loop forever.
            const int next_offset = root["next_offset"].get<int>();
            if (next_offset <= current_offset) {
                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": next_offset (" << next_offset
                                           << ") did not advance past " << current_offset << ", stopping pagination";
                break;
            }
            current_offset = next_offset;
        } catch (const std::exception& e) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": JSON parse error: " << e.what();
            return -1;
        }
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": loaded " << descriptors.size() << " manifests";
    return 0;
}

References Slic3r::PluginDescriptor::author, Slic3r::PluginChangelog::changelog, Slic3r::PluginDescriptor::changelog, Slic3r::PluginChangelog::changelog_id, Slic3r::PluginDescriptor::cloud, Slic3r::cloud_media_is_image(), Slic3r::PluginChangelog::created_time, Slic3r::PluginDescriptor::display_types, Slic3r::PluginDescriptor::entry_package, http_get(), Slic3r::PluginDescriptor::latest_version, Slic3r::PluginDescriptor::name, Slic3r::parse_cloud_author(), Slic3r::parse_cloud_display_types(), Slic3r::PluginDescriptor::plugin_key, Slic3r::PluginChangelog::plugin_uuid, Slic3r::sanitize_plugin_name(), Slic3r::PluginDescriptor::sharing_token, Slic3r::sort_plugin_changelog(), Slic3r::PluginDescriptor::thumbnail_url, Slic3r::PluginChangelog::version, and Slic3r::PluginDescriptor::version.

Here is the call graph for this function:

fetch_plugin_changelogs()

int Slic3r::OrcaCloudServiceAgent::fetch_plugin_changelogs	(	const std::vector< std::string > &	uuids,
		std::unordered_map< std::string, std::vector< PluginChangelog > > &	changelog )

{
    changelog.clear();
 
    if (uuids.empty())
        return 0;
 
    int first_error = 0;
 
    for (const std::string& uuid : uuids) {
        if (uuid.empty()) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " failed: empty plugin UUID";
            if (first_error == 0)
                first_error = -1;
            continue;
        }
 
        const std::string path = std::string(ORCA_PLUGINS_BASE) + "/" + Http::url_encode(uuid) + "/changelog?limit=100";
        std::string response_body;
        unsigned int http_code = 0;
 
        const int result = http_get(path, &response_body, &http_code);
 
        if (result != 0 || http_code != 200) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " failed: plugin_uuid=" << uuid << ", http_code=" << http_code
                                     << ", response=" << response_body;
            if (first_error == 0)
                first_error = http_code != 0 ? static_cast<int>(http_code) : result;
            continue;
        }
 
        try {
            auto root = json::parse(response_body);
 
            if (!root.contains("data") || !root["data"].is_array()) {
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": invalid response format, missing data array for plugin_uuid=" << uuid;
                if (first_error == 0)
                    first_error = -1;
                continue;
            }
 
            auto& plugin_changelog = changelog[uuid];
            plugin_changelog.clear();
            for (const auto& item : root["data"]) {
                if (!item.is_object())
                    continue;
 
                PluginChangelog entry;
                entry.changelog_id = get_json_string_field(item, "id");
                entry.plugin_uuid  = get_json_string_field(item, "plugin_id");
                if (entry.plugin_uuid.empty())
                    entry.plugin_uuid = uuid;
                entry.version      = get_json_string_field(item, "version");
                entry.changelog    = get_json_string_field(item, "changelog");
                entry.created_time = get_json_int64_field(item, "created_time");
 
                plugin_changelog.push_back(std::move(entry));
            }
            sort_plugin_changelog(plugin_changelog);
        } catch (const std::exception& e) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": JSON parse error for plugin_uuid=" << uuid << ": " << e.what();
            if (first_error == 0)
                first_error = -1;
            continue;
        }
    }
 
    return first_error;
}

References Slic3r::PluginChangelog::changelog, Slic3r::PluginChangelog::changelog_id, Slic3r::PluginChangelog::created_time, http_get(), Slic3r::PluginChangelog::plugin_uuid, Slic3r::sort_plugin_changelog(), Slic3r::Http::url_encode(), and Slic3r::PluginChangelog::version.

Here is the call graph for this function:

fetch_subscribed_manifests_into_descriptors()

int Slic3r::OrcaCloudServiceAgent::fetch_subscribed_manifests_into_descriptors	(	std::vector< PluginDescriptor > &	descriptors,
		std::vector< std::string > &	not_found,
		std::vector< std::string > &	unauthorized )

{
    std::string response_body;
    unsigned int http_code = 0;
 
    const std::string path = std::string(ORCA_SUBSCRIBED_PLUGINS) + "?include=changelog";
    int result = http_get(path, &response_body, &http_code);
 
    if (result != 0 || http_code != 200) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " failed: http_code=" << http_code;
        return result != 0 ? result : http_code;
    }
 
    try {
        BOOST_LOG_TRIVIAL(info) << response_body;
        auto root = json::parse(response_body);
 
        if (root.contains("not_found") && root["not_found"].is_array()) {
            for (const auto& item : root["not_found"])
                not_found.push_back(item.get<std::string>());
        }
        if (root.contains("unauthorised") && root["unauthorised"].is_array()) {
            for (const auto& item : root["unauthorised"])
                unauthorized.push_back(item.get<std::string>());
        }
 
        if (!root.contains("data") || !root["data"].is_array()) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": invalid response format, missing data array";
            return -1;
        }
 
        for (const auto& item : root["data"]) {
            PluginDescriptor descriptor;
            std::string uuid = get_json_string_field(item, "uuid");
            if (uuid.empty())
                uuid = get_json_string_field(item, "id");
 
            descriptor.name        = sanitize_plugin_name(get_json_string_field(item, "name"));
            descriptor.plugin_key  = uuid;
            // Cloud API "description" is intentionally not parsed: descriptions come only from the
            // plugin's Python header once installed. Cloud-only rows show a "View on OrcaCloud" link.
            descriptor.author      = parse_cloud_author(item);
            descriptor.version    = get_json_string_field(item, "version");
            descriptor.latest_version = descriptor.version;
            // Cloud "type" is cosmetic (see parse_cloud_display_types); real capability_types are
            // populated only when the plugin is actually loaded. Leave them empty here.
            descriptor.display_types = parse_cloud_display_types(item);
            descriptor.entry_package = get_json_string_field(item, "entry_package");
            descriptor.sharing_token = get_json_string_field(item, "sharing_token");
            // main_image.access_url is pre-signed, so the WebView <img> can load it without the
            // Bearer token (content_url, an API path, would 401). Images only; display-only.
            if (item.contains("main_image") && item["main_image"].is_object() && cloud_media_is_image(item["main_image"]))
                descriptor.thumbnail_url = get_json_string_field(item["main_image"], "access_url");
            if (item.contains("changelog") && item["changelog"].is_array()) {
                for (const auto& changelog_item : item["changelog"]) {
                    if (!changelog_item.is_object())
                        continue;
 
                    PluginChangelog entry;
                    entry.changelog_id = get_json_string_field(changelog_item, "id");
                    entry.plugin_uuid  = get_json_string_field(changelog_item, "plugin_id");
                    if (entry.plugin_uuid.empty())
                        entry.plugin_uuid = uuid;
                    entry.version      = get_json_string_field(changelog_item, "version");
                    entry.changelog    = get_json_string_field(changelog_item, "changelog");
                    entry.created_time = get_json_int64_field(changelog_item, "created_time");
 
                    descriptor.changelog.push_back(std::move(entry));
                }
                sort_plugin_changelog(descriptor.changelog);
            }
 
            descriptor.cloud = std::make_optional<CloudPluginState>({
                uuid,
                false,
                false,
                false,
                false
            });
 
            descriptors.push_back(std::move(descriptor));
        }
 
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": loaded " << descriptors.size() << " manifests";
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": JSON parse error: " << e.what();
        return -1;
    }
 
    return 0;
}

References Slic3r::PluginDescriptor::author, Slic3r::PluginChangelog::changelog, Slic3r::PluginDescriptor::changelog, Slic3r::PluginChangelog::changelog_id, Slic3r::PluginDescriptor::cloud, Slic3r::cloud_media_is_image(), Slic3r::PluginChangelog::created_time, Slic3r::PluginDescriptor::display_types, Slic3r::PluginDescriptor::entry_package, http_get(), Slic3r::PluginDescriptor::latest_version, Slic3r::PluginDescriptor::name, Slic3r::parse_cloud_author(), Slic3r::parse_cloud_display_types(), Slic3r::PluginDescriptor::plugin_key, Slic3r::PluginChangelog::plugin_uuid, Slic3r::sanitize_plugin_name(), Slic3r::PluginDescriptor::sharing_token, Slic3r::sort_plugin_changelog(), Slic3r::PluginDescriptor::thumbnail_url, Slic3r::PluginChangelog::version, and Slic3r::PluginDescriptor::version.

Here is the call graph for this function:

generate_uuid_for_setting_id()

std::string Slic3r::OrcaCloudServiceAgent::generate_uuid_for_setting_id ( const std::string & name, const std::string & user_id = "" )

static

{
    if (name.empty()) {
        return "";
    }
 
    // Mix user_id into the hashed input so two different users generating a setting_id
    // for an identically-named preset get distinct UUIDs. Without this, the cloud's ID
    // space collides across accounts and the second user's create gets HTTP 409 with
    // server_profile=null on every sync (the foreign owner's record is not exposed).
    static const boost::uuids::uuid orca_namespace =
        boost::uuids::string_generator()("f47ac10b-58cc-4372-a567-0e02b2c3d479");
 
    boost::uuids::name_generator_sha1 gen(orca_namespace);
    boost::uuids::uuid id = user_id.empty() ? gen(name) : gen(user_id + "/" + name);
    return boost::uuids::to_string(id);
}

Referenced by Slic3r::GUI::GUI_App::force_push_conflicting_preset(), Slic3r::GUI::GUI_App::on_http_error(), and request_setting_id().

Here is the caller graph for this function:

get_access_token()

std::string Slic3r::OrcaCloudServiceAgent::get_access_token ( ) const

overridevirtual

Return the current access token for API calls. Cloud and printer agents use this for Authorization headers.

Implements Slic3r::ICloudServiceAgent.

{
    std::lock_guard<std::mutex> lock(session_mutex);
    return session.access_token;
}

References session, and session_mutex.

Referenced by http_delete(), http_get(), http_post(), http_put(), and request_web_session_handoff().

Here is the caller graph for this function:

get_bundle_url()

std::string Slic3r::OrcaCloudServiceAgent::get_bundle_url

(

const std::string &

bundle_id

)

const

{ return cloud_base_url + "/app/bundles/subscribed-bundles/" + bundle_id; }

References cloud_base_url.

get_camera_url()

int Slic3r::OrcaCloudServiceAgent::get_camera_url ( std::string dev_id, std::function< void(std::string)> callback )

overridevirtual

Request live camera streaming URL.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_camera_url (stub)";
    if (callback)
        callback("");
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

get_cloud_base_url()

std::string Slic3r::OrcaCloudServiceAgent::get_cloud_base_url ( ) const

inline

{ return cloud_base_url; }

References cloud_base_url.

get_cloud_login_url()

std::string Slic3r::OrcaCloudServiceAgent::get_cloud_login_url ( const std::string & language = "" )

overridevirtual

Return the login URL for the cloud service.

Parameters

language

Optional language code (e.g., "en-US", "zh-CN") for localized login page. If empty, returns the default (non-localized) login URL.

Returns

The full URL to the login page, or a local file:// URL for native implementations.

Implements Slic3r::ICloudServiceAgent.

{
    std::string url = cloud_base_url + ORCA_CLOUD_LOGIN_PATH;
    if (!language.empty()) {
        url += "?lang=" + language;
    }
    return url;
}

References cloud_base_url.

get_cloud_service_host()

std::string Slic3r::OrcaCloudServiceAgent::get_cloud_service_host ( )

overridevirtual

Return the base hostname for cloud API calls (varies by region). Helpful for diagnostics and when building browser URLs.

Implements Slic3r::ICloudServiceAgent.

{ return api_base_url; }

References api_base_url.

get_design_staffpick()

int Slic3r::OrcaCloudServiceAgent::get_design_staffpick ( int offset, int limit, std::function< void(std::string)> callback )

overridevirtual

Fetch staff-picked designs from model mall.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_design_staffpick (stub)";
    if (callback)
        callback("[]");
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, and Slic3r::offset().

Here is the call graph for this function:

get_id()

std::string Slic3r::OrcaCloudServiceAgent::get_id ( ) const

inlineoverridevirtual

Implements Slic3r::ICloudServiceAgent.

{ return ORCA_CLOUD_PROVIDER; }

References Slic3r::ORCA_CLOUD_PROVIDER().

Here is the call graph for this function:

get_model_mall_detail_url()

int Slic3r::OrcaCloudServiceAgent::get_model_mall_detail_url ( std::string * url, std::string id )

overridevirtual

Build model detail page URL.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_model_mall_detail_url (stub)";
    if (url)
        *url = "";
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

get_model_mall_home_url()

int Slic3r::OrcaCloudServiceAgent::get_model_mall_home_url ( std::string * url )

overridevirtual

Get model mall home URL.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_model_mall_home_url (stub)";
    if (url)
        *url = "";
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

get_model_mall_rating_result()

int Slic3r::OrcaCloudServiceAgent::get_model_mall_rating_result ( int job_id, std::string & rating_result, unsigned int & http_code, std::string & http_error )

overridevirtual

Poll for rating result.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_model_mall_rating_result (stub)";
    rating_result = "{}";
    http_code     = 200;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

get_model_publish_url()

int Slic3r::OrcaCloudServiceAgent::get_model_publish_url ( std::string * url )

overridevirtual

Get model publish URL.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_model_publish_url (stub)";
    if (url)
        *url = "";
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

get_mw_user_4ulist()

int Slic3r::OrcaCloudServiceAgent::get_mw_user_4ulist ( int seed, int limit, std::function< void(std::string)> callback )

overridevirtual

Retrieve MakerWorld "For You" list.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_mw_user_4ulist (stub)";
    if (callback)
        callback("[]");
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

get_mw_user_preference()

int Slic3r::OrcaCloudServiceAgent::get_mw_user_preference ( std::function< void(std::string)> callback )

overridevirtual

Fetch MakerWorld user preferences.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_mw_user_preference (stub)";
    if (callback)
        callback("{}");
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

get_my_message()

int Slic3r::OrcaCloudServiceAgent::get_my_message ( int type, int after, int limit, unsigned int * http_code, std::string * http_body )

overridevirtual

Retrieve inbox/notification messages.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_my_message (stub)";
    if (http_code)
        *http_code = 200;
    if (http_body)
        *http_body = "[]";
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

get_my_profile()

int Slic3r::OrcaCloudServiceAgent::get_my_profile ( std::string token, unsigned int * http_code, std::string * http_body )

overridevirtual

Retrieve user's model mall profile.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_my_profile (stub)";
    if (http_code)
        *http_code = 200;
    if (http_body)
        *http_body = "{}";
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

get_my_token()

int Slic3r::OrcaCloudServiceAgent::get_my_token ( std::string ticket, unsigned int * http_code, std::string * http_body )

overridevirtual

Exchange a one-time login ticket (from a third-party OAuth callback) for token + profile JSON. Used by the localhost callback handler when the auth server redirects with ?ticket=...&redirect_url=... instead of passing tokens directly in the URL.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_my_token (stub) - Orca cloud uses code-based OAuth, not tickets";
    if (http_code)
        *http_code = 0;
    if (http_body)
        *http_body = "";
    return -1;
}

get_oss_config()

int Slic3r::OrcaCloudServiceAgent::get_oss_config ( std::string & config, std::string country_code, unsigned int & http_code, std::string & http_error )

overridevirtual

Get OSS configuration for image uploads.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_oss_config (stub)";
    config    = "{}";
    http_code = 200;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, and country_code.

get_plugin_download_url()

int Slic3r::OrcaCloudServiceAgent::get_plugin_download_url	(	const std::string &	uuid,
		const std::string &	requested_version,
		std::vector< PluginDownloadData > &	data,
		std::vector< PluginDownloadNotFound > &	not_found,
		std::vector< std::string > &	unauthorized )

{
    data.clear();
    not_found.clear();
    unauthorized.clear();
 
    if (uuid.empty())
        return -1;
 
    std::string response_body;
    unsigned int http_code = 0;
 
    auto api_os_type = []() {
        std::string os = platform_os_type();
        if (os == "unknown")
            return std::string{};
        if (os == "macos")
            return std::string("macosx");
        return os;
    };
 
    auto api_architecture = []() {
        const std::string arch = platform_architecture();
        if (arch == "unknown")
            return std::string{};
        return arch;
    };
 
    const std::string os   = api_os_type();
    const std::string arch = api_architecture();
    std::string path       = ORCA_PLUGIN_DOWNLOAD_URL;
    if (!os.empty())
        path += "?os=" + Http::url_encode(os);
    if (!os.empty() && !arch.empty())
        path += "&arch=" + Http::url_encode(arch);
 
    json request_item;
    request_item["plugin_id"] = uuid;
    if (!requested_version.empty())
        request_item["version"] = requested_version;
 
    json request_body;
    request_body["data"] = json::array({request_item});
 
    int result = http_post(path, request_body.dump(), &response_body, &http_code);
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": " << response_body;
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": " << "Status: " << http_code;
 
    if (result != 0 || http_code != 200) {
        if (http_code == 404)
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << " 404, plugin package for " << os << "-" << arch << " not available.";
        else
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " failed: url=" << path << ", http_code=" << http_code;
        return result != 0 ? result : http_code;
    }
 
    try {
        auto root = json::parse(response_body);
 
        if (!root.contains("data") || !root["data"].is_array()) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": invalid response format, missing data array";
            return -1;
        }
 
        for (const auto& item : root["data"]) {
            if (!item.is_object())
                continue;
 
            PluginDownloadData row;
            row.plugin_id     = get_json_string_field(item, "plugin_id");
            row.download_link = get_json_string_field(item, "download_link");
            row.requested_os  = get_json_string_field(item, "requested_os");
            row.returned_os   = get_json_string_field(item, "returned_os");
 
            if (!row.requested_os.empty() || !row.returned_os.empty())
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": artifact fallback requested_os=" << row.requested_os
                                        << ", returned_os=" << row.returned_os;
 
            data.push_back(std::move(row));
        }
 
        if (root.contains("not_found") && root["not_found"].is_array()) {
            for (const auto& item : root["not_found"]) {
                if (!item.is_object())
                    continue;
 
                PluginDownloadNotFound row;
                row.id     = get_json_string_field(item, "id");
                row.reason = get_json_string_field(item, "reason");
                not_found.push_back(std::move(row));
            }
        }
 
        if (root.contains("unauthorised") && root["unauthorised"].is_array()) {
            for (const auto& item : root["unauthorised"]) {
                if (item.is_string())
                    unauthorized.push_back(item.get<std::string>());
            }
        }
 
        return 0;
 
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": JSON parse error: " << e.what();
        return -1;
    }
 
    return -1;
}

References Slic3r::PluginDownloadData::download_link, http_post(), Slic3r::PluginDownloadNotFound::id, Slic3r::platform_architecture(), Slic3r::platform_os_type(), Slic3r::PluginDownloadData::plugin_id, Slic3r::PluginDownloadNotFound::reason, Slic3r::PluginDownloadData::requested_os, Slic3r::PluginDownloadData::returned_os, and Slic3r::Http::url_encode().

Here is the call graph for this function:

get_plugin_url()

std::string Slic3r::OrcaCloudServiceAgent::get_plugin_url

(

const std::string &

sharing_token

)

const

{ return cloud_base_url + "/p/" + Http::url_encode(sharing_token); }

References cloud_base_url, and Slic3r::Http::url_encode().

Here is the call graph for this function:

get_printer_firmware()

int Slic3r::OrcaCloudServiceAgent::get_printer_firmware ( std::string dev_id, unsigned * http_code, std::string * http_body )

overridevirtual

Fetch firmware information for a printer.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_printer_firmware (stub)";
    if (http_code)
        *http_code = 200;
    if (http_body)
        *http_body = "{}";
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

get_refresh_token()

std::string Slic3r::OrcaCloudServiceAgent::get_refresh_token ( ) const

overridevirtual

Return the current refresh token (if available).

Implements Slic3r::ICloudServiceAgent.

{
    std::lock_guard<std::mutex> lock(session_mutex);
    return session.refresh_token;
}

References session, and session_mutex.

Referenced by refresh_from_storage().

Here is the caller graph for this function:

get_setting_list()

int Slic3r::OrcaCloudServiceAgent::get_setting_list ( std::string bundle_version, ProgressFn pro_fn = nullptr, WasCancelledFn cancel_fn = nullptr )

overridevirtual

Trigger bulk download of user presets.

Implements Slic3r::ICloudServiceAgent.

{ return get_setting_list2(bundle_version, nullptr, pro_fn, cancel_fn); }

References get_setting_list2().

Here is the call graph for this function:

get_setting_list2()

int Slic3r::OrcaCloudServiceAgent::get_setting_list2 ( std::string bundle_version, CheckFn chk_fn, ProgressFn pro_fn = nullptr, WasCancelledFn cancel_fn = nullptr )

overridevirtual

Enhanced preset sync with per-item validation.

Implements Slic3r::ICloudServiceAgent.

{
    (void) bundle_version;
    bool success   = false;
    int error_code = 0;
 
    auto on_success = [&](const SyncPullResponse& resp) {
        int total      = static_cast<int>(resp.upserts.size() + resp.deletes.size());
        int processed  = 0;
        bool cancelled = false;
 
        for (const auto& upsert : resp.upserts) {
            if (cancel_fn && cancel_fn()) {
                cancelled = true;
                break;
            }
 
            if (chk_fn) {
                std::map<std::string, std::string> info;
                info[IOT_JSON_KEY_SETTING_ID]   = upsert.id;
                info[IOT_JSON_KEY_UPDATED_TIME] = std::to_string(upsert.updated_time);
 
                if (upsert.content.is_object()) {
                    for (auto& [key, value] : upsert.content.items()) {
                        if (value.is_string()) {
                            info[key] = value.get<std::string>();
                        } else {
                            info[key] = value.dump();
                        }
                    }
                }
 
                if (!info.count(IOT_JSON_KEY_NAME) && !upsert.name.empty()) {
                    info[IOT_JSON_KEY_NAME] = upsert.name;
                }
                if (!info.count(IOT_JSON_KEY_TYPE)) {
                    info[IOT_JSON_KEY_TYPE] = IOT_PRINT_TYPE_STRING;
                }
 
                chk_fn(info);
            }
 
            if (pro_fn) {
                int progress = total > 0 ? (processed * 100 / total) : 100;
                pro_fn(progress);
            }
 
            processed++;
        }
 
        if (!cancelled) {
            for (const auto& deleted_id : resp.deletes) {
                if (cancel_fn && cancel_fn()) {
                    cancelled = true;
                    break;
                }
 
                if (chk_fn) {
                    std::map<std::string, std::string> info;
                    info[IOT_JSON_KEY_SETTING_ID] = deleted_id;
                    info["deleted"]               = "true";
                    chk_fn(info);
                }
 
                if (pro_fn) {
                    int progress = total > 0 ? (processed * 100 / total) : 100;
                    pro_fn(progress);
                }
 
                processed++;
            }
        }
 
        if (!cancelled && resp.next_cursor != 0) {
            std::lock_guard<std::recursive_mutex> lock(state_mutex);
            sync_state.last_sync_timestamp = resp.next_cursor;
            save_sync_state();
        }
 
        if (pro_fn) {
            pro_fn(100);
        }
 
        success = !cancelled;
    };
 
    auto on_error = [&](int code, const std::string& err) {
        error_code = code;
        success    = false;
    };
 
    sync_pull(on_success, on_error);
 
    return success ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_GET_SETTING_LIST_FAILED;
}

References BAMBU_NETWORK_ERR_GET_SETTING_LIST_FAILED, BAMBU_NETWORK_SUCCESS, IOT_JSON_KEY_NAME, IOT_JSON_KEY_SETTING_ID, IOT_JSON_KEY_TYPE, IOT_JSON_KEY_UPDATED_TIME, IOT_PRINT_TYPE_STRING, save_sync_state(), state_mutex, sync_pull(), and sync_state.

Referenced by get_setting_list().

Here is the call graph for this function:

Here is the caller graph for this function:

get_shared_bundle()

int Slic3r::OrcaCloudServiceAgent::get_shared_bundle	(	const std::string &	bundle_id,
		std::map< std::string, std::map< std::string, std::string > > *	presets,
		BundleMetadata *	bundle_metadata )

{
    if (!presets)
        return -1;
 
    std::string response_body;
    unsigned int http_code = 0;
 
    // GET /api/v1/bundles/{id}
    std::string path = "/api/v1/bundles/" + bundle_id;
    int result       = http_get(path, &response_body, &http_code);
 
    if (result != 0 || http_code != 200) {
        BOOST_LOG_TRIVIAL(error) << "get_shared_bundle failed: bundle_id=" << bundle_id << ", http_code=" << http_code;
        return result != 0 ? result : http_code;
    }
 
    // Parse JSON response
    try {
        auto json = nlohmann::json::parse(response_body);
 
        BOOST_LOG_TRIVIAL(info) << "get_shared_bundle: response: " << response_body;
        BOOST_LOG_TRIVIAL(info) << "get_shared_bundle: shared_profile: " << json["shared_profiles"];
 
        // Parse the bundle metadata
        if (json.contains("id"))
            bundle_metadata->id = json["id"].get<std::string>();
        if (json.contains("name"))
            bundle_metadata->name = json["name"].get<std::string>();
        if (json.contains("version"))
            bundle_metadata->version = json["version"].get<std::string>();
        if (json.contains("description"))
            bundle_metadata->description = json["description"].get<std::string>();
        if (json.contains("author"))
            bundle_metadata->author = json["author"].get<std::string>();
        if (json.contains("updated_time"))
            bundle_metadata->updated_time = json["updated_time"].get<long long>();
 
        if (!json.contains("shared_profiles") || !json["shared_profiles"].is_array()) {
            BOOST_LOG_TRIVIAL(error) << "get_shared_bundle: invalid response format";
            return -1;
        }
 
        for (auto& preset_object : json["shared_profiles"]) {
            BOOST_LOG_TRIVIAL(info) << "shared profile object: " << preset_object;
 
            // Extract preset name and content
            std::string preset_name = preset_object.value("name", "");
            if (preset_name.empty()) {
                BOOST_LOG_TRIVIAL(warning) << "get_shared_bundle: preset has no name, skipping";
                continue;
            }
 
            // Parse content JSON into key-value pairs using helper (same as get_user_presets)
            std::map<std::string, std::string> value_map;
            if (preset_object.contains("content") && preset_object["content"].is_object()) {
                json_to_map(preset_object["content"].dump(), value_map);
            }
 
            // Add metadata fields to match get_user_presets format
            // These are required by PresetCollection::load_user_preset
            if (preset_object.contains("id") && value_map.find(BBL_JSON_KEY_SETTING_ID) == value_map.end()) {
                value_map[BBL_JSON_KEY_SETTING_ID] = preset_object["id"];
            }
            if (value_map.find(BBL_JSON_KEY_USER_ID) == value_map.end()) {
                // Bundle presets don't have a user_id in the traditional sense
                // Use bundle_id as a placeholder to indicate source
                value_map[BBL_JSON_KEY_USER_ID] = "bundle:" + bundle_id;
            }
            if (preset_object.contains("updated_time") && value_map.find(ORCA_JSON_KEY_UPDATE_TIME) == value_map.end()) {
                value_map[ORCA_JSON_KEY_UPDATE_TIME] = preset_object["updated_time"].dump();
            }
            if (value_map.find(BBL_JSON_KEY_NAME) == value_map.end()) {
                value_map[BBL_JSON_KEY_NAME] = preset_name;
            }
 
            // Store as: presets[preset_name][key] = value
            // This matches the format expected by PresetBundle::load_user_presets
            (*presets)[preset_name] = value_map;
        }
 
        BOOST_LOG_TRIVIAL(info) << "get_shared_bundle: loaded " << presets->size() << " presets for bundle_id=" << bundle_id;
        return 0;
 
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << "get_shared_bundle: JSON parse error: " << e.what();
        return -1;
    }
}

References Slic3r::BundleMetadata::author, BBL_JSON_KEY_NAME, BBL_JSON_KEY_SETTING_ID, BBL_JSON_KEY_USER_ID, Slic3r::BundleMetadata::description, http_get(), Slic3r::BundleMetadata::id, json_to_map(), Slic3r::BundleMetadata::name, ORCA_JSON_KEY_UPDATE_TIME, Slic3r::BundleMetadata::updated_time, and Slic3r::BundleMetadata::version.

Here is the call graph for this function:

get_slice_info()

int Slic3r::OrcaCloudServiceAgent::get_slice_info ( std::string project_id, std::string profile_id, int plate_index, std::string * slice_json )

overridevirtual

Retrieve slicing job info.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_slice_info (stub)";
    if (slice_json)
        *slice_json = "{}";
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

get_subscribed_bundles()

int Slic3r::OrcaCloudServiceAgent::get_subscribed_bundles	(	std::vector< std::pair< std::string, std::string > > *	bundles,
		std::vector< std::string > &	notfound,
		std::vector< std::string > &	unauthorized )

{
    if (!bundles)
        return -1;
 
    std::string response_body;
    unsigned int http_code = 0;
 
    // GET /api/v1/bundles
    int result = http_get("/api/v1/subscriptions", &response_body, &http_code);
 
    if (result != 0 || http_code != 200) {
        BOOST_LOG_TRIVIAL(error) << "get_subscribed_bundles failed: http_code=" << http_code << ", response=" << response_body;
        return result != 0 ? result : http_code;
    }
 
    // Parse JSON response
    try {
        auto json = nlohmann::json::parse(response_body);
 
        if (!json.contains("data") || !json["data"].is_array()) {
            BOOST_LOG_TRIVIAL(error) << "get_subscribed_bundles: invalid response format";
            return -1;
        }
        if (json.contains("not_found")) {
            // not found warning
            for (const auto& not_found : json["not_found"]) {
                notfound.push_back(not_found);
            }
        }
        if (json.contains("unauthorised")) {
            // populate something to be iterated to show warning notifications
            for (const auto& u : json["unauthorised"]) {
                unauthorized.push_back(u);
            }
        }
        // if(json.contains("privated") && json["privated"].is_array() && !json["privated"].empty())
        // {
        //     // populate something to be iterated to show warning notifications
        //     for(const auto& not_found : json["privated"])
        //     {
 
        //     }
        // }
 
        for (const auto& bundle_json : json["data"]) {
            bundles->push_back(std::make_pair(bundle_json["id"].get<std::string>(), bundle_json["version"].get<std::string>()));
        }
 
        BOOST_LOG_TRIVIAL(info) << "get_subscribed_bundles: loaded " << bundles->size() << " bundles";
        return 0;
 
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << "get_subscribed_bundles: JSON parse error: " << e.what();
        return -1;
    }
}

References http_get().

Here is the call graph for this function:

get_subtask()

int Slic3r::OrcaCloudServiceAgent::get_subtask ( BBLModelTask * task, OnGetSubTaskFn getsub_fn )

overridevirtual

Fetch publishing subtask information.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_subtask (stub)";
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

get_subtask_info()

int Slic3r::OrcaCloudServiceAgent::get_subtask_info ( std::string subtask_id, std::string * task_json, unsigned int * http_code, std::string * http_body )

overridevirtual

Fetch subtask information.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_subtask_info (stub)";
    if (task_json)
        *task_json = "{}";
    if (http_code)
        *http_code = 200;
    if (http_body)
        *http_body = "{}";
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

get_sync_state()

const SyncState & Slic3r::OrcaCloudServiceAgent::get_sync_state ( ) const

inline

{ return sync_state; }

References sync_state.

get_task_plate_index()

int Slic3r::OrcaCloudServiceAgent::get_task_plate_index ( std::string task_id, int * plate_index )

overridevirtual

Get plate index for a cloud task.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_task_plate_index (stub)";
    if (plate_index)
        *plate_index = 0;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

get_track_enable()

bool Slic3r::OrcaCloudServiceAgent::get_track_enable ( )

overridevirtual

Check if tracking is enabled.

Implements Slic3r::ICloudServiceAgent.

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    return enable_track;
}

References enable_track, and state_mutex.

get_use_encrypted_token_file()

bool Slic3r::OrcaCloudServiceAgent::get_use_encrypted_token_file

(

)

const

{ return m_use_encrypted_token_file; }

References m_use_encrypted_token_file.

get_user_avatar()

std::string Slic3r::OrcaCloudServiceAgent::get_user_avatar ( )

overridevirtual

Return the avatar URL/path for the current user.

Implements Slic3r::ICloudServiceAgent.

{
    std::lock_guard<std::mutex> lock(session_mutex);
    return session.user_avatar;
}

References session, and session_mutex.

Referenced by build_login_cmd().

Here is the caller graph for this function:

get_user_id()

std::string Slic3r::OrcaCloudServiceAgent::get_user_id ( )

overridevirtual

Return the backend-generated user ID for the current session.

Implements Slic3r::ICloudServiceAgent.

{
    std::lock_guard<std::mutex> lock(session_mutex);
    return session.user_id;
}

References session, and session_mutex.

Referenced by get_user_presets(), and request_setting_id().

Here is the caller graph for this function:

get_user_info()

int Slic3r::OrcaCloudServiceAgent::get_user_info ( int * identifier )

overridevirtual

Retrieve extended user profile info.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_user_info (stub)";
    if (identifier)
        *identifier = 0;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

get_user_name()

std::string Slic3r::OrcaCloudServiceAgent::get_user_name ( )

overridevirtual

Return the display name for the current user.

Implements Slic3r::ICloudServiceAgent.

{
    std::lock_guard<std::mutex> lock(session_mutex);
    return session.user_name;
}

References session, and session_mutex.

Referenced by build_login_cmd().

Here is the caller graph for this function:

get_user_nickname()

std::string Slic3r::OrcaCloudServiceAgent::get_user_nickname ( )

overridevirtual

Return the nickname for the current user.

Implements Slic3r::ICloudServiceAgent.

{
    std::lock_guard<std::mutex> lock(session_mutex);
    return session.user_nickname;
}

References session, and session_mutex.

Referenced by build_login_cmd().

Here is the caller graph for this function:

get_user_presets()

int Slic3r::OrcaCloudServiceAgent::get_user_presets ( std::map< std::string, std::map< std::string, std::string > > * user_presets )

overridevirtual

Fetch all presets owned by the logged-in user.

Parameters

user_presets

Map populated with [type][setting_id] = json

Implements Slic3r::ICloudServiceAgent.

{
    if (!user_presets)
        return BAMBU_NETWORK_ERR_INVALID_HANDLE;
 
    if (!is_user_login()) {
        BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: Not logged in";
        return BAMBU_NETWORK_ERR_INVALID_HANDLE;
    }
 
    bool success = false;
    std::string error_msg;
    int http_code_out = 0;
    SyncState saved_state;
 
    {
        std::lock_guard<std::recursive_mutex> lock(state_mutex);
        saved_state = sync_state;
        sync_state  = SyncState{};
    }
 
    auto on_success = [&](const SyncPullResponse& resp) {
        // Get current user_id for all presets (required by load_user_preset)
        std::string current_user_id = get_user_id();
 
        for (const auto& upsert : resp.upserts) {
            // Parse JSON content into key-value pairs using helper
            std::map<std::string, std::string> value_map;
            json_to_map(upsert.content.dump(), value_map);
 
            // Add metadata from top-level sync response if not already in content
            // These are required by PresetCollection::load_user_preset
            if (value_map.find(BBL_JSON_KEY_SETTING_ID) == value_map.end()) {
                value_map[BBL_JSON_KEY_SETTING_ID] = upsert.id;
            }
            if (value_map.find(BBL_JSON_KEY_USER_ID) == value_map.end()) {
                value_map[BBL_JSON_KEY_USER_ID] = current_user_id;
            }
            if (value_map.find(ORCA_JSON_KEY_UPDATE_TIME) == value_map.end()) {
                value_map[ORCA_JSON_KEY_UPDATE_TIME] = std::to_string(upsert.updated_time);
            }
 
            // Use preset name from content or fallback to upsert.name or upsert.id
            std::string preset_name = upsert.content.value(BBL_JSON_KEY_NAME, "");
            if (preset_name.empty()) {
                preset_name = upsert.name.empty() ? upsert.id : upsert.name;
            }
 
            // Store as: user_presets[preset_name][key] = value
            // This matches the format expected by PresetBundle::load_user_presets
            (*user_presets)[preset_name] = value_map;
        }
 
        if (resp.next_cursor != 0) {
            std::lock_guard<std::recursive_mutex> lock(state_mutex);
            sync_state.last_sync_timestamp = resp.next_cursor;
            save_sync_state();
        } else {
            std::lock_guard<std::recursive_mutex> lock(state_mutex);
            sync_state = saved_state;
        }
        success = true;
    };
 
    auto on_error = [&](int code, const std::string& err) {
        http_code_out = code;
        error_msg     = err;
        success       = false;
    };
 
    sync_pull(on_success, on_error);
 
    if (!success) {
        std::lock_guard<std::recursive_mutex> lock(state_mutex);
        sync_state = saved_state;
    }
 
    return success ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_GET_SETTING_LIST_FAILED;
}

References BAMBU_NETWORK_ERR_GET_SETTING_LIST_FAILED, BAMBU_NETWORK_ERR_INVALID_HANDLE, BAMBU_NETWORK_SUCCESS, BBL_JSON_KEY_NAME, BBL_JSON_KEY_SETTING_ID, BBL_JSON_KEY_USER_ID, get_user_id(), is_user_login(), json_to_map(), ORCA_JSON_KEY_UPDATE_TIME, save_sync_state(), state_mutex, sync_pull(), and sync_state.

Here is the call graph for this function:

get_user_print_info()

int Slic3r::OrcaCloudServiceAgent::get_user_print_info ( unsigned int * http_code, std::string * http_body )

overridevirtual

Fetch aggregated print statistics.

Implements Slic3r::ICloudServiceAgent.

{
    std::string response;
    unsigned int code = 0;
    int result = http_get(ORCA_CLOUD_PRINTER, &response, &code);
 
    if (http_code)
        *http_code = code;
 
    if (result != 0 || code != 200)
        return result != 0 ? result : BAMBU_NETWORK_ERR_GET_SETTING_LIST_FAILED;
 
    try {
        auto resp_json = nlohmann::json::parse(response);
        nlohmann::json devices = nlohmann::json::array();
 
        for (const auto& printer : resp_json.value("data", nlohmann::json::array())) {
            const std::string role = printer.value("access_role", "");
            if (role.empty() || role == "viewer")
                continue;
 
            nlohmann::json device;
            device["dev_id"]   = printer.value("id", "");
            device["dev_name"] = printer.value("name", "");
            if (printer.contains("model") && printer["model"].is_string())
                device["dev_model_name"] = printer["model"].get<std::string>();
 
            bool online = false;
            if (printer.contains("status_snapshot") && printer["status_snapshot"].is_object()) {
                const auto& status = printer["status_snapshot"].value("status", nlohmann::json::object());
                online = status.value("connection", nlohmann::json::object()).value("state", "") == "online";
                if (status.contains("job") && status["job"].is_object())
                    device["task_status"] = status["job"].value("state", "");
            }
            device["dev_online"] = online;
            devices.push_back(std::move(device));
        }
 
        if (http_body) {
            nlohmann::json out;
            out["devices"] = std::move(devices);
            *http_body = out.dump();
        }
    } catch (const std::exception&) {
        return BAMBU_NETWORK_ERR_GET_SETTING_LIST_FAILED;
    }
 
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_ERR_GET_SETTING_LIST_FAILED, BAMBU_NETWORK_SUCCESS, and http_get().

Here is the call graph for this function:

get_user_tasks()

int Slic3r::OrcaCloudServiceAgent::get_user_tasks ( TaskQueryParams params, std::string * http_body )

overridevirtual

Query user's tasks/prints.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_user_tasks (stub)";
    if (http_body)
        *http_body = "[]";
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

get_version()

std::string Slic3r::OrcaCloudServiceAgent::get_version ( )

overridevirtual

Return the version of the cloud service implementation.

Implements Slic3r::ICloudServiceAgent.

{ return "OrcaCloudServiceAgent 1.0.0"; }

http_delete()

int Slic3r::OrcaCloudServiceAgent::http_delete ( const std::string & path, std::string * response_body, unsigned int * http_code )

private

{
    std::string url = api_base_url + path;
    BOOST_LOG_TRIVIAL(trace) << "OrcaCloudServiceAgent: DELETE " << url;
 
    ensure_token_fresh("http_delete_" + path);
 
    auto perform = [&]() {
        HttpResult result;
        try {
            auto http = Http::del(url);
            http.tls_verify(true);
 
            std::string token = get_access_token();
 
            auto headers = data_headers();
            for (const auto& pair : headers) {
                http.header(pair.first, pair.second);
            }
 
            if (!token.empty()) {
                http.header("Authorization", "Bearer " + token);
            }
 
            http.on_complete([&](std::string resp_body, unsigned resp_status) {
                    result.success = true;
                    result.status  = resp_status;
                    result.body    = resp_body;
                })
                .on_error([&](std::string resp_body, std::string error, unsigned resp_status) {
                    result.success = false;
                    result.status  = resp_status == 0 ? 404 : resp_status;
                    result.body    = resp_body;
                    BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: HTTP error - " << error;
                })
                .timeout_max(30)
                .perform_sync();
 
        } catch (const std::exception& e) {
            BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: http_delete exception - " << e.what();
        }
        return result;
    };
 
    HttpResult res = perform();
    bool suppress = resolve_unauthorized(res, perform, "http_delete_" + path);
 
    if (response_body)
        *response_body = res.body;
    if (http_code)
        *http_code = res.status;
 
    if (!suppress && (!res.success || res.status >= 400)) {
        invoke_http_error_callback(res.status, res.body);
    }
 
    return (res.success && !suppress) ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_CONNECT_FAILED;
}

References api_base_url, BAMBU_NETWORK_ERR_CONNECT_FAILED, BAMBU_NETWORK_SUCCESS, Slic3r::OrcaCloudServiceAgent::HttpResult::body, data_headers(), Slic3r::Http::del(), ensure_token_fresh(), get_access_token(), Slic3r::http, invoke_http_error_callback(), resolve_unauthorized(), Slic3r::OrcaCloudServiceAgent::HttpResult::status, Slic3r::OrcaCloudServiceAgent::HttpResult::success, and Slic3r::trace().

Referenced by delete_setting(), unsubscribe_bundle(), and unsubscribe_plugins().

Here is the call graph for this function:

Here is the caller graph for this function:

http_get()

int Slic3r::OrcaCloudServiceAgent::http_get ( const std::string & path, std::string * response_body, unsigned int * http_code )

private

{
    std::string url = api_base_url + path;
    BOOST_LOG_TRIVIAL(trace) << "OrcaCloudServiceAgent: GET " << url;
 
    if (!ensure_token_fresh("http_get_" + path))
        BOOST_LOG_TRIVIAL(warning) << "ensure_token_fresh returned false";
 
    auto perform = [&]() {
        HttpResult result;
        try {
            auto http = Http::get(url);
            http.tls_verify(true);
 
            std::string token = get_access_token();
 
            auto headers = data_headers();
            for (const auto& pair : headers) {
                http.header(pair.first, pair.second);
            }
 
            if (!token.empty()) {
                http.header("Authorization", "Bearer " + token);
            }
 
            http.on_complete([&](std::string body, unsigned resp_status) {
                    result.success = true;
                    result.status  = resp_status;
                    result.body    = body;
                })
                .on_error([&](std::string body, std::string error, unsigned resp_status) {
                    result.success = false;
                    result.status  = resp_status == 0 ? 404 : resp_status;
                    result.body    = body;
                    BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: HTTP error - " << error;
                })
                .timeout_max(30)
                .perform_sync();
 
        } catch (const std::exception& e) {
            BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: http_get exception - " << e.what();
        }
        return result;
    };
 
    HttpResult res = perform();
    bool suppress = resolve_unauthorized(res, perform, "http_get_" + path);
 
    if (response_body)
        *response_body = res.body;
    if (http_code)
        *http_code = res.status;
 
    if (!suppress && (!res.success || res.status >= 400)) {
        invoke_http_error_callback(res.status, res.body);
    }
 
    return (res.success && !suppress) ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_CONNECT_FAILED;
}

References api_base_url, BAMBU_NETWORK_ERR_CONNECT_FAILED, BAMBU_NETWORK_SUCCESS, Slic3r::OrcaCloudServiceAgent::HttpResult::body, data_headers(), ensure_token_fresh(), Slic3r::Http::get(), get_access_token(), Slic3r::http, invoke_http_error_callback(), resolve_unauthorized(), Slic3r::OrcaCloudServiceAgent::HttpResult::status, Slic3r::OrcaCloudServiceAgent::HttpResult::success, and Slic3r::trace().

Referenced by fetch_mine_manifests_into_descriptors(), fetch_plugin_changelogs(), fetch_subscribed_manifests_into_descriptors(), get_shared_bundle(), get_subscribed_bundles(), get_user_print_info(), and sync_pull().

Here is the call graph for this function:

Here is the caller graph for this function:

http_post()

int Slic3r::OrcaCloudServiceAgent::http_post ( const std::string & path, const std::string & body, std::string * response_body, unsigned int * http_code )

private

{
    std::string url = api_base_url + path;
    BOOST_LOG_TRIVIAL(trace) << "OrcaCloudServiceAgent: POST " << url;
 
    ensure_token_fresh("http_post_" + path);
 
    auto perform = [&]() {
        HttpResult result;
        try {
            auto http = Http::post(url);
            http.tls_verify(true);
 
            std::string token = get_access_token();
 
            auto headers = data_headers();
            for (const auto& pair : headers) {
                http.header(pair.first, pair.second);
            }
 
            if (!token.empty()) {
                http.header("Authorization", "Bearer " + token);
            }
 
            http.header("Content-Type", "application/json");
            http.set_post_body(body);
 
            http.on_complete([&](std::string resp_body, unsigned resp_status) {
                    result.success = true;
                    result.status  = resp_status;
                    result.body    = resp_body;
                })
                .on_error([&](std::string resp_body, std::string error, unsigned resp_status) {
                    result.success = false;
                    result.status  = resp_status == 0 ? 404 : resp_status;
                    result.body    = resp_body;
                    BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: HTTP error - " << error;
                })
                .timeout_max(30)
                .perform_sync();
 
        } catch (const std::exception& e) {
            BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: http_post exception - " << e.what();
        }
        return result;
    };
 
    HttpResult res = perform();
    bool suppress = resolve_unauthorized(res, perform, "http_post_" + path);
 
    if (response_body)
        *response_body = res.body;
    if (http_code)
        *http_code = res.status;
 
    // 409 is a push-only domain conflict; sync_push re-fires the error callback with the
    // local preset name injected (the raw server body omits it for tombstone conflicts),
    // so skip the generic nameless auto-fire here to avoid a duplicate, nameless event.
    if (!suppress && (!res.success || res.status >= 400) && res.status != 409) {
        invoke_http_error_callback(res.status, res.body);
    }
 
    return (res.success && !suppress) ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_CONNECT_FAILED;
}

References api_base_url, BAMBU_NETWORK_ERR_CONNECT_FAILED, BAMBU_NETWORK_SUCCESS, Slic3r::OrcaCloudServiceAgent::HttpResult::body, data_headers(), ensure_token_fresh(), get_access_token(), Slic3r::http, invoke_http_error_callback(), Slic3r::Http::post(), resolve_unauthorized(), Slic3r::OrcaCloudServiceAgent::HttpResult::status, Slic3r::OrcaCloudServiceAgent::HttpResult::success, and Slic3r::trace().

Referenced by get_plugin_download_url(), subscribe_plugin(), and sync_push().

Here is the call graph for this function:

Here is the caller graph for this function:

http_post_auth()

bool Slic3r::OrcaCloudServiceAgent::http_post_auth ( const std::string & path, const std::string & body, std::string * response_body, unsigned int * http_code )

private

{
    std::string url = auth_base_url + path + "?scope=local";
    std::string token;
    std::map<std::string, std::string> headers_copy;
    {
        std::lock_guard<std::mutex> lock(session_mutex);
        token = session.access_token;
    }
    {
        std::lock_guard<std::mutex> lock(headers_mutex);
        headers_copy = extra_headers;
    }
    {
        std::lock_guard<std::recursive_mutex> lock(state_mutex);
        for (const auto& pair : auth_headers) {
            headers_copy[pair.first] = pair.second;
        }
    }
 
    BOOST_LOG_TRIVIAL(trace) << "OrcaCloudServiceAgent: POST (auth) " << url;
 
    try {
        auto http = Http::post(url);
        http.tls_verify(true);
 
        for (const auto& pair : headers_copy) {
            http.header(pair.first, pair.second);
        }
 
        if (!token.empty()) {
            http.header("Authorization", "Bearer " + token);
        }
 
        http.remove_header("Content-Type");
        http.header("Content-Type", "application/json");
        http.set_post_body(body);
 
        bool success        = false;
        unsigned int status = 0;
        std::string resp_body;
 
        http.on_complete([&](std::string body, unsigned resp_status) {
                success   = true;
                status    = resp_status;
                resp_body = body;
            })
            .on_error([&](std::string body, std::string error, unsigned resp_status) {
                success   = false;
                status    = resp_status == 0 ? 404 : resp_status;
                resp_body = body;
                BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: HTTP (auth) error - " << error;
            })
            .timeout_max(30)
            .perform_sync();
 
        if (response_body)
            *response_body = resp_body;
        if (http_code)
            *http_code = status;
        return success;
 
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: http_post_auth exception - " << e.what();
        if (http_code)
            *http_code = 0;
        return false;
    }
}

References auth_base_url, auth_headers, extra_headers, headers_mutex, Slic3r::http, Slic3r::Http::post(), session, session_mutex, state_mutex, and Slic3r::trace().

Referenced by user_logout().

Here is the call graph for this function:

Here is the caller graph for this function:

http_post_token()

bool Slic3r::OrcaCloudServiceAgent::http_post_token ( const std::string & body, std::string * response_body, unsigned int * http_code, const std::string & url = "" )

private

{
    std::map<std::string, std::string> headers_copy;
    std::string url;
    {
        std::lock_guard<std::mutex> lock(headers_mutex);
        url          = custom_url.empty() ? (auth_base_url + auth_constants::TOKEN_PATH) : custom_url;
        headers_copy = extra_headers;
    }
 
    // Add auth headers
    {
        std::lock_guard<std::recursive_mutex> lock(state_mutex);
        for (const auto& pair : auth_headers) {
            headers_copy[pair.first] = pair.second;
        }
    }
 
    BOOST_LOG_TRIVIAL(trace) << "OrcaCloudServiceAgent: POST " << url;
 
    bool has_apikey = false;
    for (const auto& pair : headers_copy) {
        if (pair.first == "apikey")
            has_apikey = true;
    }
    if (!has_apikey) {
        BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: http_post_token - apikey header MISSING! Token request will likely fail.";
    }
 
    try {
        auto http = Http::post(url);
        http.tls_verify(true);
 
        for (const auto& pair : headers_copy) {
            http.header(pair.first, pair.second);
        }
 
        http.remove_header("Authorization");
        http.remove_header("Content-Type");
        http.header("Content-Type", "application/json");
        http.set_post_body(body);
 
        bool success        = false;
        unsigned int status = 0;
        std::string resp_body;
 
        http.on_complete([&](std::string body, unsigned resp_status) {
                success   = true;
                status    = resp_status;
                resp_body = body;
            })
            .on_error([&](std::string body, std::string error, unsigned resp_status) {
                success   = false;
                status    = resp_status;  // keep 0 for "no response" so the refresh classifier sees a transport failure
                resp_body = body;
                BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: HTTP error - " << error;
            })
            // Keep this timeout finite: refresh_from_storage holds a cross-process lock across
            // this call, so an unbounded refresh POST would let one instance wedge token refresh
            // for every other Orca instance on the machine.
            .timeout_max(30)
            .perform_sync();
 
        if (response_body)
            *response_body = resp_body;
        if (http_code)
            *http_code = status;
        return success;
 
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: http_post_token exception - " << e.what();
        if (http_code)
            *http_code = 0;
        return false;
    }
}

References auth_base_url, auth_headers, extra_headers, headers_mutex, Slic3r::http, Slic3r::Http::post(), state_mutex, Slic3r::auth_constants::TOKEN_PATH, and Slic3r::trace().

Referenced by exchange_auth_code(), and refresh_session_with_token().

Here is the call graph for this function:

Here is the caller graph for this function:

http_put()

int Slic3r::OrcaCloudServiceAgent::http_put ( const std::string & path, const std::string & body, std::string * response_body, unsigned int * http_code )

private

{
    std::string url = api_base_url + path;
    BOOST_LOG_TRIVIAL(trace) << "OrcaCloudServiceAgent: PUT " << url;
 
    ensure_token_fresh("http_put_" + path);
 
    auto perform = [&]() {
        HttpResult result;
        try {
            auto http = Http::put(url);
            http.tls_verify(true);
 
            std::string token = get_access_token();
 
            auto headers = data_headers();
            for (const auto& pair : headers) {
                http.header(pair.first, pair.second);
            }
 
            if (!token.empty()) {
                http.header("Authorization", "Bearer " + token);
            }
 
            http.header("Content-Type", "application/json");
            http.set_post_body(body);
 
            http.on_complete([&](std::string resp_body, unsigned resp_status) {
                    result.success = true;
                    result.status  = resp_status;
                    result.body    = resp_body;
                })
                .on_error([&](std::string resp_body, std::string error, unsigned resp_status) {
                    result.success = false;
                    result.status  = resp_status == 0 ? 404 : resp_status;
                    result.body    = resp_body;
                    BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: HTTP error - " << error;
                })
                .timeout_max(30)
                .perform_sync();
 
        } catch (const std::exception& e) {
            BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: http_put exception - " << e.what();
        }
        return result;
    };
 
    HttpResult res = perform();
    bool suppress = resolve_unauthorized(res, perform, "http_put_" + path);
 
    if (response_body)
        *response_body = res.body;
    if (http_code)
        *http_code = res.status;
 
    if (!suppress && (!res.success || res.status >= 400)) {
        invoke_http_error_callback(res.status, res.body);
    }
 
    return (res.success && !suppress) ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_CONNECT_FAILED;
}

References api_base_url, BAMBU_NETWORK_ERR_CONNECT_FAILED, BAMBU_NETWORK_SUCCESS, Slic3r::OrcaCloudServiceAgent::HttpResult::body, data_headers(), ensure_token_fresh(), get_access_token(), Slic3r::http, invoke_http_error_callback(), Slic3r::Http::put(), resolve_unauthorized(), Slic3r::OrcaCloudServiceAgent::HttpResult::status, Slic3r::OrcaCloudServiceAgent::HttpResult::success, and Slic3r::trace().

Here is the call graph for this function:

init_log()

int Slic3r::OrcaCloudServiceAgent::init_log ( )

overridevirtual

Initialize the logging backend for the agent. Call after set_config_dir() so logs have a destination.

Implements Slic3r::ICloudServiceAgent.

{ return BAMBU_NETWORK_SUCCESS; }

References BAMBU_NETWORK_SUCCESS.

invoke_http_error_callback()

void Slic3r::OrcaCloudServiceAgent::invoke_http_error_callback ( unsigned http_code, const std::string & http_body )

private

{
    AppOnHttpErrorFn callback;
    QueueOnMainFn queue_fn;
    {
        std::lock_guard<std::recursive_mutex> lock(state_mutex);
        callback = on_http_error_fn;
        queue_fn = queue_on_main_fn;
    }
 
    if (callback) {
        CloudEvent event{ORCA_CLOUD_PROVIDER};
        if (queue_fn) {
            queue_fn([callback, event, http_code, http_body]() { callback(event, http_code, http_body); });
        } else {
            callback(event, http_code, http_body);
        }
    }
}

References on_http_error_fn, Slic3r::ORCA_CLOUD_PROVIDER(), queue_on_main_fn, and state_mutex.

Referenced by http_delete(), http_get(), http_post(), http_put(), request_web_session_handoff(), run_health_check(), and sync_push().

Here is the call graph for this function:

Here is the caller graph for this function:

invoke_server_connected_callback()

void Slic3r::OrcaCloudServiceAgent::invoke_server_connected_callback ( int return_code, int reason_code )

private

{
    AppOnServerConnectedFn callback;
    QueueOnMainFn queue_fn;
    {
        std::lock_guard<std::recursive_mutex> lock(state_mutex);
        callback = on_server_connected_fn;
        queue_fn = queue_on_main_fn;
    }
 
    if (callback) {
        CloudEvent event{ORCA_CLOUD_PROVIDER};
        if (queue_fn) {
            queue_fn([callback, event, return_code, reason_code]() { callback(event, return_code, reason_code); });
        } else {
            callback(event, return_code, reason_code);
        }
    }
}

References on_server_connected_fn, Slic3r::ORCA_CLOUD_PROVIDER(), queue_on_main_fn, and state_mutex.

Referenced by run_health_check().

Here is the call graph for this function:

Here is the caller graph for this function:

is_refresh_running()

bool Slic3r::OrcaCloudServiceAgent::is_refresh_running ( ) const

inline

{ return refresh_running.load(); }

References refresh_running.

is_server_connected()

bool Slic3r::OrcaCloudServiceAgent::is_server_connected ( )

overridevirtual

Return whether the server is currently reachable.

Implements Slic3r::ICloudServiceAgent.

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    return is_connected;
}

References is_connected, and state_mutex.

is_user_login()

bool Slic3r::OrcaCloudServiceAgent::is_user_login ( )

overridevirtual

Check whether a valid authenticated session exists.

Implements Slic3r::ICloudServiceAgent.

{
    std::lock_guard<std::mutex> lock(session_mutex);
    return session.logged_in;
}

References session, and session_mutex.

Referenced by build_login_cmd(), and get_user_presets().

Here is the caller graph for this function:

json_to_map()

void Slic3r::OrcaCloudServiceAgent::json_to_map ( const std::string & json, std::map< std::string, std::string > & map )

private

{
    try {
        auto j = nlohmann::json::parse(json);
        for (auto it = j.begin(); it != j.end(); ++it) {
            if (it.value().is_string()) {
                map[it.key()] = it.value().get<std::string>();
            } else {
                map[it.key()] = it.value().dump();
            }
        }
    } catch (...) {}
}

Referenced by get_shared_bundle(), and get_user_presets().

Here is the caller graph for this function:

load_sync_state()

void Slic3r::OrcaCloudServiceAgent::load_sync_state

(

)

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
 
    if (sync_state_path.empty())
        return;
 
    try {
        std::ifstream ifs(sync_state_path);
        if (ifs.good()) {
            std::string line;
            if (std::getline(ifs, line)) {
                sync_state.last_sync_timestamp = std::stoll(line);
            }
        }
    } catch (...) {
        sync_state.last_sync_timestamp = 0;
    }
}

References state_mutex, sync_state, and sync_state_path.

Referenced by set_user_session().

Here is the caller graph for this function:

load_user_secret()

bool Slic3r::OrcaCloudServiceAgent::load_user_secret

(

std::string &

out_secret

)

{
    out_secret.clear();
 
    if (m_use_encrypted_token_file) {
        // Load from encrypted file only
        compute_fallback_path();
        if (wxFileExists(wxString::FromUTF8(secret_fallback_path.c_str()))) {
            std::ifstream ifs(secret_fallback_path, std::ios::binary);
            std::string payload((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
            auto key = sha256_bytes(get_encryption_key());
            std::string plain;
            if (!key.empty()) {
                std::string encoded_payload = payload;
                bool integrity_ok           = true;
 
                if (payload.rfind("v2:", 0) == 0) {
                    auto delim = payload.find(':', 3);
                    if (delim == std::string::npos) {
                        BOOST_LOG_TRIVIAL(warning) << "payload missing delim ':'.";
                        integrity_ok = false;
                    } else {
                        std::string stored_hmac  = payload.substr(3, delim - 3);
                        std::string lower_stored = stored_hmac;
                        std::transform(lower_stored.begin(), lower_stored.end(), lower_stored.begin(), ::tolower);
                        encoded_payload = payload.substr(delim + 1);
 
                        std::string computed_hmac = hmac_sha256_hex(encoded_payload, key);
                        std::transform(computed_hmac.begin(), computed_hmac.end(), computed_hmac.begin(), ::tolower);
                        if (computed_hmac.empty() || computed_hmac != lower_stored) {
                            integrity_ok = false;
                            BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: user secret integrity check failed (HMAC mismatch)";
                        }
                    }
                }
 
                if (integrity_ok && aes256gcm_decrypt(encoded_payload, key, plain) && !plain.empty()) {
                    secret_stored = true;
                    out_secret = plain;
                    // Upgrade legacy payloads to signed format
                    if (payload.rfind("v2:", 0) != 0) {
                        persist_user_secret(out_secret);
                    }
                    return true;
                }
            }
        }
    } else {
        wxSecretStore store = wxSecretStore::GetDefault();
        if (store.IsOk()) {
            wxString username;
            wxSecretValue secret;
            if (store.Load(SECRET_STORE_SERVICE, username, secret) && secret.IsOk()) {
                out_secret.assign(static_cast<const char*>(secret.GetData()), secret.GetSize());
                if (!out_secret.empty()) {
                    secret_stored = true;
                    return true;
                }
            }
        }
    }
 
    return false;
}

References compute_fallback_path(), m_use_encrypted_token_file, persist_user_secret(), secret_fallback_path, and secret_stored.

Referenced by refresh_from_storage(), refresh_session_with_token(), and start().

Here is the call graph for this function:

Here is the caller graph for this function:

map_to_json()

std::string Slic3r::OrcaCloudServiceAgent::map_to_json ( const std::map< std::string, std::string > & map )

private

{
    nlohmann::json j;
    for (const auto& pair : map) {
        j[pair.first] = pair.second;
    }
    return j.dump();
}

modify_printer_name()

int Slic3r::OrcaCloudServiceAgent::modify_printer_name ( std::string dev_id, std::string dev_name )

overridevirtual

Update printer name in cloud profile.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: modify_printer_name (stub)";
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

persist_user_secret()

void Slic3r::OrcaCloudServiceAgent::persist_user_secret

(

const std::string &

secret

)

{
    if (secret.empty()) {
        clear_user_secret();
        return;
    }
 
    bool stored = false;
 
    if (m_use_encrypted_token_file) {
        // Use encrypted file only
        auto key = sha256_bytes(get_encryption_key());
        if (key.empty()) {
            BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: cannot derive key for user secret file storage";
            return;
        }
 
        std::string payload;
        if (!aes256gcm_encrypt(secret, key, payload)) {
            BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: failed to encrypt user secret for file storage";
            return;
        }
 
        std::string signed_payload = payload;
        if (auto mac = hmac_sha256_hex(payload, key); !mac.empty()) {
            signed_payload = "v2:" + mac + ":" + payload;
        }
 
        compute_fallback_path();
        if (secret_fallback_path.empty()) {
            BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: no user secret storage path available; skipping file persistence";
            return;
        }
        wxFileName path(wxString::FromUTF8(secret_fallback_path.c_str()));
        path.MakeAbsolute();
        if (!wxFileName::DirExists(path.GetPath())) {
            wxFileName::Mkdir(path.GetPath(), wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL);
        }
 
        if (const std::error_code ec = write_file_atomically(secret_fallback_path, signed_payload, /*binary=*/true))
            BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: cannot write user secret file " << secret_fallback_path << ": " << ec.message();
        else
            stored = true;
    } else {
        // Use wxSecretStore only
        wxSecretStore store = wxSecretStore::GetDefault();
        if (store.IsOk()) {
            wxSecretValue secret_value(wxString::FromUTF8(secret.c_str()));
            if (store.Save(SECRET_STORE_SERVICE, SECRET_STORE_USER, secret_value)) {
                stored = true;
            } else {
                BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: System Keychain save failed";
            }
        } else {
            BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: System Keychain not available";
        }
    }
 
    if (stored) {
        secret_stored = true;
    }
}

References clear_user_secret(), compute_fallback_path(), m_use_encrypted_token_file, secret_fallback_path, secret_stored, and Slic3r::write_file_atomically().

Referenced by load_user_secret(), and set_user_session().

Here is the call graph for this function:

Here is the caller graph for this function:

pkce()

const OrcaCloudServiceAgent::PkceBundle & Slic3r::OrcaCloudServiceAgent::pkce

(

)

{
    if (pkce_bundle.verifier.empty() || pkce_bundle.challenge.empty() || pkce_bundle.state.empty()) {
        regenerate_pkce();
    }
    return pkce_bundle;
}

References pkce_bundle, and regenerate_pkce().

Referenced by build_login_cmd().

Here is the call graph for this function:

Here is the caller graph for this function:

put_model_mall_rating()

int Slic3r::OrcaCloudServiceAgent::put_model_mall_rating ( int design_id, int score, std::string content, std::vector< std::string > images, unsigned int & http_code, std::string & http_error )

overridevirtual

Submit a review for a marketplace design.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: put_model_mall_rating (stub)";
    http_code = 200;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

put_rating_picture_oss()

int Slic3r::OrcaCloudServiceAgent::put_rating_picture_oss ( std::string & config, std::string & pic_oss_path, std::string model_id, int profile_id, unsigned int & http_code, std::string & http_error )

overridevirtual

Upload rating images to OSS.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: put_rating_picture_oss (stub)";
    http_code = 200;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

put_setting()

int Slic3r::OrcaCloudServiceAgent::put_setting ( std::string setting_id, std::string name, std::map< std::string, std::string > * values_map, unsigned int * http_code, bool force = false )

overridevirtual

Update or create a preset with a known setting_id.

Implements Slic3r::ICloudServiceAgent.

{
    // Extract original_updated_time for Optimistic Concurrency Control
    // If present, server will verify version before update. If absent, treated as insert.
    std::string original_updated_time;
    if (values_map) {
        auto it = values_map->find(IOT_JSON_KEY_UPDATED_TIME);
        if (it != values_map->end()) {
            original_updated_time = it->second;
        }
    }
 
    // Build content JSON
    nlohmann::json content;
    content["name"] = name;
 
    if (values_map && !values_map->empty()) {
        for (const auto& pair : *values_map) {
            // Skip updated_time - it's used for OCC, not as content
            if (pair.first == IOT_JSON_KEY_UPDATED_TIME)
                continue;
            content[pair.first] = pair.second;
        }
    }
 
    auto result = sync_push(setting_id, name, content, original_updated_time, force);
    if (http_code) *http_code = result.http_code;
 
    if (result.success) {
        if (values_map && result.new_updated_time != 0) {
            (*values_map)[IOT_JSON_KEY_UPDATED_TIME] = std::to_string(result.new_updated_time);
        }
        return BAMBU_NETWORK_SUCCESS;
    }
 
    if (result.http_code == 409) {
        // Conflict - update values_map with server version
        if (values_map && result.server_version.updated_time != 0) {
            (*values_map)[IOT_JSON_KEY_UPDATED_TIME] = std::to_string(result.server_version.updated_time);
        }
        BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: put_setting conflict - server_updated_time="
                                   << result.server_version.updated_time;
    }
 
    BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: put_setting failed - " << result.error_message;
    return BAMBU_NETWORK_ERR_PUT_SETTING_FAILED;
}

References BAMBU_NETWORK_ERR_PUT_SETTING_FAILED, BAMBU_NETWORK_SUCCESS, IOT_JSON_KEY_UPDATED_TIME, and sync_push().

Here is the call graph for this function:

query_bind_status()

int Slic3r::OrcaCloudServiceAgent::query_bind_status ( std::vector< std::string > query_list, unsigned int * http_code, std::string * http_body )

overridevirtual

Query binding status for multiple devices.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: query_bind_status (stub)";
    if (http_code)
        *http_code = 200;
    if (http_body)
        *http_body = "{}";
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

refresh_connection()

int Slic3r::OrcaCloudServiceAgent::refresh_connection ( )

overridevirtual

Force a server state recheck, clearing any cached state. The result arrives through is_server_connected() and OnServerConnectedFn. Implementations may return before the check finishes, fold the call into a check already in flight, and ignore calls while the agent is shutting down.

Implements Slic3r::ICloudServiceAgent.

{
    if (health_check_stopped.load())
        return BAMBU_NETWORK_ERR_CANCELED;
    bool expected = false;
    if (!health_check_running.compare_exchange_strong(expected, true))
        return BAMBU_NETWORK_SUCCESS;
    if (health_check_thread.joinable())
        health_check_thread.join(); // the previous check is done; only its thread exit is left
    try {
        health_check_thread = std::thread([this] {
            try {
                run_health_check(&health_check_stopped);
            } catch (...) {
                // Callback dispatch (std::function copies, CallAfter) must not terminate the app.
                BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: health check worker exception";
            }
            health_check_running.store(false);
        });
    } catch (...) {
        // std::system_error, or std::bad_alloc for the callable: leave the next tick free to retry.
        health_check_running.store(false);
        BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: cannot start health check";
        return BAMBU_NETWORK_ERR_CONNECTION_TO_SERVER_FAILED;
    }
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_ERR_CANCELED, BAMBU_NETWORK_ERR_CONNECTION_TO_SERVER_FAILED, BAMBU_NETWORK_SUCCESS, health_check_running, health_check_stopped, health_check_thread, and run_health_check().

Here is the call graph for this function:

refresh_from_storage()

RefreshResult Slic3r::OrcaCloudServiceAgent::refresh_from_storage	(	const std::string &	reason,
		bool	async = false )

{
    (void) async; // currently all callers are calling this function synchronous anyway
 
    // Blocks until we own the lock (kernel sleep, no spin). Cannot deadlock permanently:
    // the refresh POST is bounded (http_post_token timeout_max) and the lock auto-releases
    // on process death, so no holder can keep it longer than that bound.
    InterProcessRefreshTokenLock lock(token_lock_path());
    if (!lock.locked()) {
        // Lock syscall genuinely failed (rare). Proceed best-effort rather than give up.
        BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: token refresh lock unavailable, "
                                      "proceeding unsynchronized (reason=" << reason << ")";
    }
 
    std::string refresh_token;
    std::string user_secret;
 
    // We read the refresh token from the OS keychain as the source of truth
    if (load_user_secret(user_secret) && !user_secret.empty()) {
        SessionInfo stored_session;
        parse_stored_secret(user_secret, refresh_token, stored_session);
    }
 
    // We only read from memory if the read from OS keychain fails
    if (refresh_token.empty())
        refresh_token = get_refresh_token();
 
    if (refresh_token.empty()) {
        BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: no refresh token available for refresh (reason=" << reason << ")";
        return RefreshResult::AuthRejected;  // no persisted token: nothing to preserve
    }
 
    // Synchronous: hold the lock across the network round-trip AND the write-back that
    // set_user_session performs, so the rotation is atomic w.r.t. other instances.
    return refresh_now(refresh_token, reason, /*async=*/false);
}

References Slic3r::AuthRejected, get_refresh_token(), load_user_secret(), Slic3r::parse_stored_secret(), refresh_now(), and token_lock_path().

Referenced by attempt_refresh_after_unauthorized(), and refresh_if_expiring().

Here is the call graph for this function:

Here is the caller graph for this function:

refresh_if_expiring()

bool Slic3r::OrcaCloudServiceAgent::refresh_if_expiring	(	std::chrono::seconds	skew,
		const std::string &	reason )

{
    const auto needs_refresh = [&] {
        std::lock_guard<std::mutex> lock(session_mutex);
        return should_refresh_locked(skew);
    };
    if (!needs_refresh())
        return true;
 
    // A refresh may already be running on another thread, e.g. the one start() launches. Wait for
    // it and check again instead of spending the refresh token it is rotating. Bounded: the
    // refresh POST times out after 30 s.
    const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(60);
    while (refresh_running.load() && std::chrono::steady_clock::now() < deadline)
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    if (!needs_refresh())
        return true;
 
    // First attempt. refresh_from_storage blocks on the cross-process lock and reads the
    // freshest token from the store, so cross-instance contention is already resolved here.
    RefreshResult r = refresh_from_storage(reason, false);
    if (r == RefreshResult::Success)      return true;
    if (r == RefreshResult::AuthRejected) return false;  // definitive: retrying the same token can't help
 
    // One retry, only for a transient network failure of the refresh POST (lost response,
    // timeout, 429/5xx -> Transient). The retry re-acquires the lock and re-reads the store.
    std::this_thread::sleep_for(std::chrono::milliseconds(750));
    if (!needs_refresh())
        return true;
    return refresh_from_storage(reason + "_retry", false) == RefreshResult::Success;
}

References Slic3r::AuthRejected, refresh_from_storage(), refresh_running, session_mutex, should_refresh_locked(), and Slic3r::Success.

Referenced by ensure_token_fresh().

Here is the call graph for this function:

Here is the caller graph for this function:

refresh_now()

RefreshResult Slic3r::OrcaCloudServiceAgent::refresh_now	(	const std::string &	refresh_token,
		const std::string &	reason,
		bool	async = false )

{
    if (refresh_token.empty()) return RefreshResult::AuthRejected;  // nothing to refresh
 
    bool expected = false;
    if (!refresh_running.compare_exchange_strong(expected, true)) {
        BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: refresh already running, skip (reason=" << reason << ")";
        // Another refresh is already in flight. Treat as transient so we keep the session
        // instead of logging out: that in-flight refresh surfaces its own Success/AuthRejected,
        // so a genuine rejection is only deferred to the next request, never lost.
        return RefreshResult::Transient;
    }
 
    auto worker = [this, refresh_token, reason]() {
        RefreshResult r = refresh_session_with_token(refresh_token, reason);
        refresh_running.store(false);
        return r;
    };
 
    if (async) {
        if (refresh_thread.joinable()) {
            refresh_thread.join();
        }
        refresh_thread = std::thread([worker]() { worker(); });
        // Fire-and-forget: the outcome isn't known yet and no current caller consumes it.
        // Return Transient (indeterminate) rather than implying a completed, successful refresh.
        return RefreshResult::Transient;
    }
 
    return worker();
}

References Slic3r::AuthRejected, refresh_running, refresh_session_with_token(), refresh_thread, and Slic3r::Transient.

Referenced by refresh_from_storage(), and start().

Here is the call graph for this function:

Here is the caller graph for this function:

refresh_session_with_token()

RefreshResult Slic3r::OrcaCloudServiceAgent::refresh_session_with_token	(	const std::string &	refresh_token,
		const std::string &	reason = "" )

{
    std::string body = "{\"refresh_token\":\"" + refresh_token + "\"}";
    std::string url  = auth_base_url + auth_constants::TOKEN_PATH + "?grant_type=refresh_token";
    std::string response;
    unsigned int http_code = 0;
    // http_post_token sets http_code to 0 when the server could not be reached.
    http_post_token(body, &response, &http_code, url);
 
    const long long now_s   = now_epoch_seconds();
    const long long last_ok = last_refresh_success_epoch.load(std::memory_order_relaxed);
    const long long since_last_ok = (last_ok == 0) ? -1 : (now_s - last_ok); // -1 = no success yet this process
    const long long since_start   = now_s - agent_start_epoch;
    const std::string log_reason  = reason.empty() ? "-" : reason;
 
    bool established = false;
    if (http_code >= 200 && http_code < 300) {
        if (session_handler) {
            established = session_handler(response);
        } else {
            // No session handler set - parse the token response directly and establish the
            // session, so OrcaCloudServiceAgent is self-contained without external setup.
            try {
                established = set_user_session(json::parse(response));
            } catch (const std::exception& e) {
                BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: token refresh parse exception - " << e.what();
            }
        }
        if (established) {
            last_refresh_success_epoch.store(now_s, std::memory_order_relaxed);
            BOOST_LOG_TRIVIAL(info) << "[auth] event=refresh_ok reason=" << log_reason
                                    << " secs_since_last_success=" << since_last_ok;
        }
    } else {
        // Diagnostics to classify a future refresh_token_already_used incident from logs alone
        //  - secs_since_last_success large (or -1 = none this process) => stale token beyond the
        //    reuse-grace window (the ">1h gap" residual).
        //  - stored_differs=true => another instance/device already rotated the token in the
        //    shared secret store (the multi-session residual).
        const std::string error_code = extract_error_code(response);
 
        // Only meaningful when the server actually rejected us (not a bare transport failure).
        bool stored_present = false, stored_differs = false;
        if (http_code >= 400) {
            std::string stored_secret, stored_token;
            SessionInfo ignored;
            if (load_user_secret(stored_secret) && !stored_secret.empty()
                && parse_stored_secret(stored_secret, stored_token, ignored) && !stored_token.empty()) {
                stored_present = true;
                stored_differs = (stored_token != refresh_token);
            }
        }
 
        std::string user_id_copy;
        {
            std::lock_guard<std::mutex> lock(session_mutex);
            user_id_copy = session.user_id;
        }
 
        std::string truncated_response = response.size() > 200 ? response.substr(0, 200) + "..." : response;
        BOOST_LOG_TRIVIAL(warning) << "[auth] event=refresh_rejected http_code=" << http_code
                                   << " error_code=" << (error_code.empty() ? "-" : error_code)
                                   << " reason=" << log_reason
                                   << " stored_present=" << (stored_present ? "true" : "false")
                                   << " stored_differs=" << (stored_differs ? "true" : "false")
                                   << " secs_since_last_success=" << since_last_ok
                                   << " secs_since_start=" << since_start
                                   << " user_id=" << (user_id_copy.empty() ? "-" : user_id_copy)
                                   << " response_body=" << truncated_response;
    }
 
    return classify_refresh_result(http_code, established);
}

References agent_start_epoch, auth_base_url, Slic3r::classify_refresh_result(), Slic3r::extract_error_code(), http_post_token(), last_refresh_success_epoch, load_user_secret(), Slic3r::now_epoch_seconds(), Slic3r::parse_stored_secret(), session, session_handler, session_mutex, set_user_session(), and Slic3r::auth_constants::TOKEN_PATH.

Referenced by refresh_now().

Here is the call graph for this function:

Here is the caller graph for this function:

regenerate_pkce()

void Slic3r::OrcaCloudServiceAgent::regenerate_pkce

(

)

{
    pkce_bundle.verifier  = generate_code_verifier();
    pkce_bundle.challenge = sha256_base64url(pkce_bundle.verifier);
    pkce_bundle.state     = generate_state_token();
    if (pkce_bundle.redirect.empty()) {
        pkce_bundle.redirect = "http://localhost:" + std::to_string(pkce_bundle.loopback_port) + auth_constants::LOOPBACK_PATH;
    }
}

References Slic3r::auth_constants::LOOPBACK_PATH, and pkce_bundle.

Referenced by OrcaCloudServiceAgent(), build_login_cmd(), pkce(), and start().

Here is the caller graph for this function:

request_setting_id()

std::string Slic3r::OrcaCloudServiceAgent::request_setting_id ( std::string name, std::map< std::string, std::string > * values_map, unsigned int * http_code )

overridevirtual

Request a new preset identifier from the server.

Implements Slic3r::ICloudServiceAgent.

{
    std::string new_id = generate_uuid_for_setting_id(name, get_user_id());
    if (new_id.empty()) {
        BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: request_setting_id failed - name is empty";
        return "";
    }
 
    nlohmann::json content;
    content["name"] = name;
    content["type"] = IOT_PRINT_TYPE_STRING; // Default type
 
    if (values_map && !values_map->empty()) {
        for (const auto& pair : *values_map) {
            // Skip updated_time - it's metadata, not content
            if (pair.first == IOT_JSON_KEY_UPDATED_TIME)
                continue;
            content[pair.first] = pair.second;
        }
    }
 
    // Use sync_push to create the profile (no original_updated_time for new profiles per spec)
    auto result = sync_push(new_id, name, content, "");
    if (http_code)
        *http_code = result.http_code;
 
    // 409 duplicate_profile_uuid in the create path means the deterministic id we
    // just generated already exists in this account: the earlier create succeeded.
    // Adopt it instead of failing, so sync_preset persists the id and stops retrying.
    if (result.http_code == 409 && result.conflict_code == -2
        && !result.server_version.id.empty() && result.server_version.id == new_id) {
        if (values_map && result.server_version.updated_time != 0)
            (*values_map)[IOT_JSON_KEY_UPDATED_TIME] = std::to_string(result.server_version.updated_time);
        if (http_code)
            *http_code = 200;
        BOOST_LOG_TRIVIAL(info) << "OrcaCloudServiceAgent: request_setting_id adopted existing profile id " << new_id << " (409 duplicate_profile_uuid)";
        return new_id;
    }
 
    if (result.success) {
        if (values_map && result.new_updated_time != 0) {
            (*values_map)[IOT_JSON_KEY_UPDATED_TIME] = std::to_string(result.new_updated_time);
        }
        return new_id;
    }
 
    BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: request_setting_id failed - " << result.error_message
                             << " - http code: " << result.http_code;
    return "";
}

References generate_uuid_for_setting_id(), get_user_id(), IOT_JSON_KEY_UPDATED_TIME, IOT_PRINT_TYPE_STRING, and sync_push().

Here is the call graph for this function:

request_web_session_handoff()

int Slic3r::OrcaCloudServiceAgent::request_web_session_handoff	(	std::string &	token_hash,
		std::string &	error_code,
		unsigned int &	http_code )

{
    token_hash.clear();
    error_code.clear();
    http_code = 0;
 
    const std::string url = api_base_url + ORCA_WEB_SESSION_HANDOFF_PATH;
    BOOST_LOG_TRIVIAL(trace) << "OrcaCloudServiceAgent: POST " << ORCA_WEB_SESSION_HANDOFF_PATH;
 
    // Refresh the desktop token the usual way before minting (newest access token).
    ensure_token_fresh("web_session_handoff");
 
    auto perform = [&]() {
        HttpResult result;
        try {
            auto http = Http::post(url);
            http.tls_verify(true);
 
            const std::string token = get_access_token();
 
            auto headers = data_headers();
            for (const auto& pair : headers) {
                http.header(pair.first, pair.second);
            }
            if (!token.empty()) {
                http.header("Authorization", "Bearer " + token);
            }
 
            // No request body: the endpoint identifies the user by the bearer token alone.
            http.on_complete([&](std::string resp_body, unsigned resp_status) {
                    result.success = true;
                    result.status  = resp_status;
                    result.body    = resp_body;
                })
                .on_error([&](std::string resp_body, std::string error, unsigned resp_status) {
                    result.success = false;
                    result.status  = resp_status == 0 ? 404 : resp_status;
                    result.body    = resp_body;
                    BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: web-session-handoff HTTP error - " << error;
                })
                .timeout_max(30)
                .perform_sync();
 
        } catch (const std::exception& e) {
            BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: web-session-handoff exception - " << e.what();
        }
        return result;
    };
 
    HttpResult res = perform();
    // Reuse the shared 401 policy (refresh once, then retry), exactly like http_get/http_post:
    // `suppress` is true for a transient refresh failure (keep the session and token, no logout)
    // and false when the refresh token was rejected — so a 401 that remains after the refresh
    // surfaces through the generic HTTP-error callback and drives the normal desktop logout.
    // Every other handoff status (409/429/503/transport) stays silent here, so the page can
    // offer "Try again" instead of the desktop showing a generic cloud error.
    const bool suppress = resolve_unauthorized(res, perform, "web_session_handoff");
    if (!suppress && res.status == 401)
        invoke_http_error_callback(res.status, res.body);
 
    http_code = res.status;
    if (res.status == 200) {
        const json j = json::parse(res.body, nullptr, false);
        if (!j.is_discarded() && j.is_object() && j.contains("token_hash") && j["token_hash"].is_string())
            token_hash = j["token_hash"].get<std::string>();
    } else {
        error_code = handoff_error_code(res.body);
    }
 
    return (res.success && res.status == 200) ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_CONNECT_FAILED;
}

References api_base_url, BAMBU_NETWORK_ERR_CONNECT_FAILED, BAMBU_NETWORK_SUCCESS, Slic3r::OrcaCloudServiceAgent::HttpResult::body, data_headers(), ensure_token_fresh(), get_access_token(), Slic3r::handoff_error_code(), Slic3r::http, invoke_http_error_callback(), Slic3r::Http::post(), resolve_unauthorized(), Slic3r::OrcaCloudServiceAgent::HttpResult::status, Slic3r::OrcaCloudServiceAgent::HttpResult::success, and Slic3r::trace().

Here is the call graph for this function:

resolve_unauthorized()

bool Slic3r::OrcaCloudServiceAgent::resolve_unauthorized ( HttpResult & res, const std::function< HttpResult()> & perform, const std::string & reason )

private

{
    if (res.status != 401)
        return false;
 
    RefreshResult rr = attempt_refresh_after_unauthorized(reason);
    if (rr == RefreshResult::Success) {
        res = perform();   // refreshed: retry the original request with the new token
        return false;
    }
 
    // Transient (no connection / 5xx / 429 / ambiguous): keep the session and token,
    // suppress the auth error so the GUI does not log the user out.
    // AuthRejected (refresh token genuinely rejected): let the 401 surface -> logout.
    return rr == RefreshResult::Transient;
}

References attempt_refresh_after_unauthorized(), Slic3r::OrcaCloudServiceAgent::HttpResult::status, Slic3r::Success, and Slic3r::Transient.

Referenced by http_delete(), http_get(), http_post(), http_put(), and request_web_session_handoff().

Here is the call graph for this function:

Here is the caller graph for this function:

run_health_check()

bool Slic3r::OrcaCloudServiceAgent::run_health_check ( const std::atomic_bool * cancel )

private

{
    if (cancel && cancel->load())
        return false;
 
    HttpResult res;
    try {
        auto http = Http::get(api_base_url + ORCA_HEALTH_PATH);
        http.tls_verify(true);
        for (const auto& [key, value] : data_headers())
            http.header(key, value);
        if (cancel)
            http.on_progress([cancel](Http::Progress, bool& cancel_request) { cancel_request = cancel->load(); });
        http.on_complete([&](std::string body, unsigned status) {
                res.success = true;
                res.status  = status;
                res.body    = std::move(body);
            })
            .on_error([&](std::string body, std::string error, unsigned status) {
                res.status = status == 0 ? 404 : status; // same mapping as http_get
                res.body   = std::move(body);
                BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: health check failed - " << error;
            })
            .timeout_max(30)
            .perform_sync();
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: health check exception - " << e.what();
    }
    // Stopped mid-request: report nothing, the receivers may be going away.
    if (cancel && cancel->load())
        return false;
 
    const bool connected = res.success;
    {
        std::lock_guard<std::recursive_mutex> lock(state_mutex);
        is_connected = connected;
    }
    if (!connected)
        invoke_http_error_callback(res.status, res.body);
    invoke_server_connected_callback(connected ? 0 : -1, res.status);
    return connected;
}

References api_base_url, Slic3r::OrcaCloudServiceAgent::HttpResult::body, data_headers(), Slic3r::Http::get(), Slic3r::http, invoke_http_error_callback(), invoke_server_connected_callback(), is_connected, state_mutex, Slic3r::OrcaCloudServiceAgent::HttpResult::status, and Slic3r::OrcaCloudServiceAgent::HttpResult::success.

Referenced by connect_server(), and refresh_connection().

Here is the call graph for this function:

Here is the caller graph for this function:

save_sync_state()

void Slic3r::OrcaCloudServiceAgent::save_sync_state

(

)

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
 
    if (sync_state_path.empty())
        return;
 
    if (const std::error_code ec = write_file_atomically(sync_state_path, std::to_string(sync_state.last_sync_timestamp)))
        BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: failed to save the sync state: " << ec.message();
}

References state_mutex, sync_state, sync_state_path, and Slic3r::write_file_atomically().

Referenced by get_setting_list2(), and get_user_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

set_api_base_url()

void Slic3r::OrcaCloudServiceAgent::set_api_base_url

(

const std::string &

url

)

{ api_base_url = url; }

References api_base_url.

set_auth_base_url()

void Slic3r::OrcaCloudServiceAgent::set_auth_base_url

(

const std::string &

url

)

{ auth_base_url = url; }

References auth_base_url.

set_cert_file()

int Slic3r::OrcaCloudServiceAgent::set_cert_file ( std::string folder, std::string filename )

overridevirtual

Register the client certificate file for TLS authentication. May be unused by some implementations (e.g., OrcaCloudServiceAgent).

Implements Slic3r::ICloudServiceAgent.

{
    // Not used by OrcaCloudServiceAgent (OAuth doesn't need client certs)
    (void) folder;
    (void) filename;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

set_cloud_base_url()

void Slic3r::OrcaCloudServiceAgent::set_cloud_base_url

(

const std::string &

url

)

{ cloud_base_url = url; }

References cloud_base_url.

set_config_dir()

int Slic3r::OrcaCloudServiceAgent::set_config_dir ( std::string config_dir )

overridevirtual

Provide the writable configuration directory for storing auth state. Must be called before start().

Implements Slic3r::ICloudServiceAgent.

{
    config_dir = cfg_dir;
    wxFileName fallback(wxString::FromUTF8(cfg_dir.c_str()), secret_constants::USER_SECRET_FILENAME);
    fallback.MakeAbsolute();
    secret_fallback_path = fallback.GetFullPath().ToStdString();
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, config_dir, secret_fallback_path, and Slic3r::secret_constants::USER_SECRET_FILENAME.

set_country_code()

int Slic3r::OrcaCloudServiceAgent::set_country_code ( std::string country_code )

overridevirtual

Set the country code for region-specific backend selection.

Implements Slic3r::ICloudServiceAgent.

{
    country_code = code;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, and country_code.

set_get_country_code_fn()

int Slic3r::OrcaCloudServiceAgent::set_get_country_code_fn ( GetCountryCodeFn fn )

overridevirtual

Provide country code getter callback.

Implements Slic3r::ICloudServiceAgent.

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    get_country_code_fn = fn;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, get_country_code_fn, and state_mutex.

set_on_http_error_fn()

int Slic3r::OrcaCloudServiceAgent::set_on_http_error_fn ( AppOnHttpErrorFn fn )

overridevirtual

Register HTTP error callback.

Implements Slic3r::ICloudServiceAgent.

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    on_http_error_fn = fn;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, on_http_error_fn, and state_mutex.

set_on_login_complete_handler()

void Slic3r::OrcaCloudServiceAgent::set_on_login_complete_handler

(

OnLoginCompleteHandler

handler

)

{ on_login_complete_handler = std::move(handler); }

References on_login_complete_handler.

set_on_server_connected_fn()

int Slic3r::OrcaCloudServiceAgent::set_on_server_connected_fn ( AppOnServerConnectedFn fn )

overridevirtual

Register server connection status callback.

Implements Slic3r::ICloudServiceAgent.

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    on_server_connected_fn = fn;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, on_server_connected_fn, and state_mutex.

set_queue_on_main_fn()

int Slic3r::OrcaCloudServiceAgent::set_queue_on_main_fn ( QueueOnMainFn fn )

overridevirtual

Provide main thread queue callback.

Implements Slic3r::ICloudServiceAgent.

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    queue_on_main_fn = fn;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, queue_on_main_fn, and state_mutex.

set_session_handler()

void Slic3r::OrcaCloudServiceAgent::set_session_handler

(

SessionHandler

handler

)

{ session_handler = std::move(handler); }

References session_handler.

set_use_encrypted_token_file()

void Slic3r::OrcaCloudServiceAgent::set_use_encrypted_token_file

(

bool

use

)

{ m_use_encrypted_token_file = use; }

References m_use_encrypted_token_file.

set_user_session() [1/2]

bool Slic3r::OrcaCloudServiceAgent::set_user_session	(	const nlohmann::json &	session_json,
		bool	notify_login = true )

{
    std::string access_token = get_json_string_field(session_json, "access_token");
    if (access_token.empty()) {
        access_token = get_json_string_field(session_json, "token");
    }
    std::string refresh_token = get_json_string_field(session_json, "refresh_token");
 
    std::string user_id, username, nickname, avatar;
    if (session_json.contains("user") && session_json["user"].is_object()) {
        // Nested format (Orca cloud / GoTrue response)
        const auto& user = session_json["user"];
        user_id          = get_json_string_field(user, "id");
 
        if (user.contains("user_metadata") && user["user_metadata"].is_object()) {
            const auto& meta = user["user_metadata"];
            username         = get_json_string_field(meta, "username"); // Orca Cloud's unique username
 
            // Orca Cloud's primary display name field is display_name.
            // Fallback to different names from different providers if display_name is not set.
            nickname = resolve_display_name(get_json_string_field(meta, "display_name"), get_json_string_field(meta, "nickname"),
                                            get_json_string_field(meta, "full_name"), get_json_string_field(meta, "name"), username);
            avatar   = get_json_string_field(meta, "avatar_url");
        }
    } else {
        // Flat format (WebView direct token flow)
        user_id  = get_json_string_field(session_json, "user_id");
        username = get_json_string_field(session_json, "username");
        nickname = resolve_display_name(get_json_string_field(session_json, "display_name"),
                                        get_json_string_field(session_json, "nickname"), get_json_string_field(session_json, "full_name"),
                                        get_json_string_field(session_json, "name"), username);
        avatar   = get_json_string_field(session_json, "avatar");
    }
 
    if (access_token.empty() || user_id.empty()) {
        BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: session payload missing access_token or user id";
        return false;
    }
 
    bool success = set_user_session(access_token, user_id, username, nickname, avatar, refresh_token);
    if (success && notify_login && on_login_complete_handler) {
        on_login_complete_handler(true, user_id);
    }
    return success;
}

References on_login_complete_handler, and set_user_session().

Here is the call graph for this function:

set_user_session() [2/2]

bool Slic3r::OrcaCloudServiceAgent::set_user_session	(	const std::string &	token,
		const std::string &	user_id,
		const std::string &	username,
		const std::string &	nickname,
		const std::string &	avatar,
		const std::string &	refresh_token = "",
		bool	persist = true )

{
    std::chrono::system_clock::time_point exp_tp{};
    decode_jwt_expiry(token, exp_tp);
 
    {
        std::lock_guard<std::mutex> lock(session_mutex);
        session.access_token  = token;
        session.refresh_token = refresh_token;
        session.user_id       = user_id;
        session.user_name     = username;
        session.user_nickname = nickname;
        session.user_avatar   = avatar;
        session.expires_at    = exp_tp;
        session.logged_in     = true;
    }
 
    if (persist) {
        // Store user session on disk to not block use from using
        // an already logged in account if internet is not available.
        // Don't store access token though, we should always refresh it
        // once user is back online.
        json sec             = json::object();
        sec["refresh_token"] = refresh_token;
        sec["user_id"]       = user_id;
        sec["username"]      = username;
        sec["nickname"]      = nickname;
        persist_user_secret(sec.dump());
    }
 
    // Set per-user sync state path
    if (!config_dir.empty() && !user_id.empty()) {
        boost::filesystem::path user_dir = boost::filesystem::path(config_dir) / "user" / user_id;
        if (!boost::filesystem::exists(user_dir)) {
            boost::filesystem::create_directories(user_dir);
        }
        sync_state_path = (user_dir / ORCA_SYNC_STATE_FILE).string();
        load_sync_state();
    }
 
    BOOST_LOG_TRIVIAL(info) << "OrcaCloudServiceAgent: set_user_session - user_id=" << user_id << ", username=" << username;
    return true;
}

References config_dir, decode_jwt_expiry(), load_sync_state(), persist_user_secret(), session, session_mutex, and sync_state_path.

Referenced by change_user(), refresh_session_with_token(), set_user_session(), and start().

Here is the call graph for this function:

Here is the caller graph for this function:

should_refresh_locked()

bool Slic3r::OrcaCloudServiceAgent::should_refresh_locked ( std::chrono::seconds skew ) const

private

{
    if (!session.logged_in)
        return false;
    if (session.expires_at.time_since_epoch().count() == 0)
        return true;
 
    auto now = std::chrono::system_clock::now();
    return (session.expires_at - now) <= skew;
}

References session.

Referenced by refresh_if_expiring().

Here is the caller graph for this function:

start()

int Slic3r::OrcaCloudServiceAgent::start ( )

overridevirtual

Start the agent, performing any expensive initialization. Typically regenerates PKCE bundles and attempts silent sign-in.

Implements Slic3r::ICloudServiceAgent.

{
    regenerate_pkce();
 
    // Attempt silent sign-in from stored refresh token
    std::string stored_secret;
    if (load_user_secret(stored_secret) && !stored_secret.empty()) {
        // Backward compatibility: if secret it a json, then read it as use session,
        // which allows us to refresh it in a background thread to speed up the app startup;
        // otherwise it's a plain refresh token, then we force a sync refresh
        std::string refresh_token;
        SessionInfo stored_session;
        if (parse_stored_secret(stored_secret, refresh_token, stored_session)) {
            if (stored_session.logged_in) {
                // We have a previously saved user session, use it. Skip re-persisting: the secret was
                // just loaded from disk, so writing the identical bytes back is wasted startup I/O.
                set_user_session(stored_session.access_token, stored_session.user_id, stored_session.user_name,
                                 stored_session.user_nickname, stored_session.user_avatar, stored_session.refresh_token,
                                 /*persist=*/false);
            }
            refresh_now(refresh_token, "refresh token", stored_session.logged_in);
        }
    }
 
    return BAMBU_NETWORK_SUCCESS;
}

References Slic3r::OrcaCloudServiceAgent::SessionInfo::access_token, BAMBU_NETWORK_SUCCESS, load_user_secret(), Slic3r::OrcaCloudServiceAgent::SessionInfo::logged_in, Slic3r::parse_stored_secret(), refresh_now(), Slic3r::OrcaCloudServiceAgent::SessionInfo::refresh_token, regenerate_pkce(), set_user_session(), Slic3r::OrcaCloudServiceAgent::SessionInfo::user_avatar, Slic3r::OrcaCloudServiceAgent::SessionInfo::user_id, Slic3r::OrcaCloudServiceAgent::SessionInfo::user_name, and Slic3r::OrcaCloudServiceAgent::SessionInfo::user_nickname.

Here is the call graph for this function:

start_publish()

int Slic3r::OrcaCloudServiceAgent::start_publish ( PublishParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, std::string * out )

overridevirtual

Run multi-stage publishing workflow.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: start_publish (stub)";
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

start_subscribe()

int Slic3r::OrcaCloudServiceAgent::start_subscribe ( std::string module )

overridevirtual

Subscribe to a logical module (e.g., "printer", "user").

Implements Slic3r::ICloudServiceAgent.

{
    (void) module;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, and Slic3r::module().

Here is the call graph for this function:

stop_health_check()

void Slic3r::OrcaCloudServiceAgent::stop_health_check

(

)

{
    health_check_stopped.store(true);
    if (health_check_thread.joinable())
        health_check_thread.join();
}

References health_check_stopped, and health_check_thread.

Referenced by ~OrcaCloudServiceAgent().

Here is the caller graph for this function:

stop_subscribe()

int Slic3r::OrcaCloudServiceAgent::stop_subscribe ( std::string module )

overridevirtual

Stop listening to a formerly subscribed module.

Implements Slic3r::ICloudServiceAgent.

{
    (void) module;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, and Slic3r::module().

Here is the call graph for this function:

subscribe_plugin()

int Slic3r::OrcaCloudServiceAgent::subscribe_plugin

(

const std::string &

plugin_uuid

)

{
    if (plugin_uuid.empty())
        return -1;
 
    const std::string request_body = json{{"plugin_id", plugin_uuid}}.dump();
    std::string response_body;
    unsigned int http_code = 0;
 
    const int result = http_post(ORCA_SUBSCRIBED_PLUGINS, request_body, &response_body, &http_code);
    // Treat an existing subscription as success: the requested cloud state already exists.
    if (http_code == 409)
        return 0;
    if (result != 0 || (http_code != 200 && http_code != 201)) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " failed: http_code=" << http_code << ", response=" << response_body;
        return http_code != 0 ? static_cast<int>(http_code) : result;
    }
 
    return 0;
}

References http_post().

Here is the call graph for this function:

sync_pull()

int Slic3r::OrcaCloudServiceAgent::sync_pull ( std::function< void(const SyncPullResponse &)> on_success, std::function< void(int http_code, const std::string &error)> on_error )

private

{
    std::string path = ORCA_SYNC_PULL_PATH;
    if (sync_state.last_sync_timestamp != 0) {
        path += "?cursor=" + std::to_string(sync_state.last_sync_timestamp);
    }
 
    std::string response;
    unsigned int http_code = 0;
    int result             = http_get(path, &response, &http_code);
 
    // Handle 410 Gone - cursor too old, need full resync
    if (http_code == 410) {
        BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: sync_pull returned 410 Gone - cursor too old, triggering full resync";
        clear_sync_state();
        // Retry without cursor
        path   = ORCA_SYNC_PULL_PATH;
        result = http_get(path, &response, &http_code);
    }
 
    if (result != BAMBU_NETWORK_SUCCESS || (http_code != 200 && http_code != 304)) {
        BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: sync_pull failed - http_code=" << http_code << " - path=" << path;
        if (on_error)
            on_error(http_code, response);
        return BAMBU_NETWORK_ERR_GET_SETTING_LIST_FAILED;
    }
 
    if (http_code == 304) {
        if (on_success) {
            SyncPullResponse empty_response;
            on_success(empty_response);
        }
        return BAMBU_NETWORK_SUCCESS;
    }
 
    try {
        auto json = nlohmann::json::parse(response);
        SyncPullResponse resp;
        resp.next_cursor = json.value("next_cursor", 0);
 
        if (json.contains("upserts") && json["upserts"].is_array()) {
            for (const auto& item : json["upserts"]) {
                ProfileUpsert upsert;
                upsert.id           = item.value("id", "");
                upsert.name         = item.value("name", "");
                upsert.updated_time = item.value(ORCA_JSON_KEY_UPDATE_TIME, 0);
                upsert.created_time = item.value(ORCA_JSON_KEY_CREATED_TIME, 0);
                if (item.contains("content")) {
                    upsert.content = item["content"];
                }
                resp.upserts.push_back(upsert);
            }
        }
 
        if (json.contains("deletes") && json["deletes"].is_array()) {
            for (const auto& item : json["deletes"]) {
                resp.deletes.push_back(item.get<std::string>());
            }
        }
 
        if (on_success)
            on_success(resp);
        return BAMBU_NETWORK_SUCCESS;
 
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: sync_pull parse error - " << e.what();
        if (on_error)
            on_error(http_code, e.what());
        return BAMBU_NETWORK_ERR_INVALID_RESULT;
    }
}

References BAMBU_NETWORK_ERR_GET_SETTING_LIST_FAILED, BAMBU_NETWORK_ERR_INVALID_RESULT, BAMBU_NETWORK_SUCCESS, clear_sync_state(), Slic3r::ProfileUpsert::content, Slic3r::ProfileUpsert::created_time, Slic3r::SyncPullResponse::deletes, http_get(), Slic3r::ProfileUpsert::id, Slic3r::ProfileUpsert::name, Slic3r::SyncPullResponse::next_cursor, ORCA_JSON_KEY_CREATED_TIME, ORCA_JSON_KEY_UPDATE_TIME, sync_state, Slic3r::ProfileUpsert::updated_time, and Slic3r::SyncPullResponse::upserts.

Referenced by get_setting_list2(), and get_user_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

sync_push()

SyncPushResult Slic3r::OrcaCloudServiceAgent::sync_push	(	const std::string &	profile_id,
		const std::string &	name,
		const nlohmann::json &	content,
		const std::string &	original_updated_time = "",
		bool	force = false )

{
    SyncPushResult result;
    result.success        = false;
    result.http_code      = 0;
    result.conflict_code  = 0;
    result.server_deleted = false;
 
    nlohmann::json body;
    body["id"]      = profile_id;
    body["name"]    = name;
    body["content"] = content;
    if (!original_updated_time.empty()) {
        body["original_updated_time"] = original_updated_time;
    }
 
    // Validate payload size before upload
    std::string body_str = body.dump();
    if (body_str.size() > ORCA_SYNC_MAX_PAYLOAD_SIZE) {
        result.http_code     = 413; // HTTP 413 Payload Too Large
        result.success       = false;
        result.error_message = "Preset content exceeds 1MB size limit (actual: " + std::to_string(body_str.size()) + " bytes)";
        BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: sync_push payload too large - " << "size=" << body_str.size() << " bytes, "
                                 << "limit=" << ORCA_SYNC_MAX_PAYLOAD_SIZE << " bytes, " << "profile_id=" << profile_id;
        return result;
    }
 
    std::string response;
    unsigned int http_code = 0;
    int http_result = http_post(force ? ORCA_SYNC_FORCE_PUSH_PATH : ORCA_SYNC_PUSH_PATH, body_str, &response, &http_code);
 
    result.http_code = http_code;
 
    if (http_code == 409) {
        // Conflict - parse server version
        nlohmann::json err_body;
        try {
            auto json = nlohmann::json::parse(response);
            err_body = json;
            if (json.is_null()) {
                result.server_deleted = true;
            } else if (json.is_object()) {
                result.conflict_code = json.value("code", 0);
                if (json.contains("server_profile") && !json["server_profile"].is_null()) {
                    auto& profile_data                 = json["server_profile"];
                    result.server_version.id           = profile_data.value("id", "");
                    result.server_version.name         = profile_data.value("name", "");
                    result.server_version.updated_time = profile_data.value(ORCA_JSON_KEY_UPDATE_TIME, 0);
                }
            }
        } catch (...) {}
        // Create-path duplicate_profile_uuid (-2) is an idempotent success: the deterministic id
        // already exists, so the caller adopts the returned id. Skip the conflict notification,
        // otherwise every already-imported preset would raise a Pull/Force-push prompt on each launch.
        const bool is_create               = original_updated_time.empty();
        const bool auto_resolved_duplicate = (is_create && result.conflict_code == -2);
        if (!auto_resolved_duplicate) {
            // Surface the conflict via the http-error callback with the local preset name injected.
            // The raw server body omits the name for tombstone (-3) conflicts (server_profile is null),
            // but the GUI needs it to regenerate the deterministic setting_id for a force push.
            if (!err_body.is_object())
                err_body = nlohmann::json::object();
            err_body["name"] = name;
            invoke_http_error_callback(409, err_body.dump());
        }
        result.error_message = response;
        return result;
    }
 
    if (http_code != 200) {
        result.error_message = response;
        return result;
    }
 
    // Success
    try {
        auto json               = nlohmann::json::parse(response);
        result.new_updated_time = json.value(ORCA_JSON_KEY_UPDATE_TIME, 0);
        if (result.new_updated_time != 0) {
            result.success = true;
        } else {
            result.error_message = "Server response missing required updated_time timestamp";
        }
    } catch (const std::exception& e) {
        result.error_message = e.what();
    }
 
    return result;
}

References Slic3r::SyncPushResult::conflict_code, Slic3r::SyncPushResult::error_message, Slic3r::SyncPushResult::http_code, http_post(), Slic3r::ProfileUpsert::id, invoke_http_error_callback(), Slic3r::ProfileUpsert::name, Slic3r::SyncPushResult::new_updated_time, ORCA_JSON_KEY_UPDATE_TIME, Slic3r::SyncPushResult::server_deleted, Slic3r::SyncPushResult::server_version, Slic3r::SyncPushResult::success, and Slic3r::ProfileUpsert::updated_time.

Referenced by put_setting(), and request_setting_id().

Here is the call graph for this function:

Here is the caller graph for this function:

token_lock_path()

std::string Slic3r::OrcaCloudServiceAgent::token_lock_path ( ) const

private

{
    if (config_dir.empty())
        return {};
    wxFileName lock(wxString::FromUTF8(config_dir.c_str()), "orca_refresh_token.lock");
    lock.MakeAbsolute();
    return lock.GetFullPath().ToStdString();
}

References config_dir.

Referenced by refresh_from_storage().

Here is the caller graph for this function:

track_enable()

int Slic3r::OrcaCloudServiceAgent::track_enable ( bool enable )

overridevirtual

Enable/disable telemetry.

Implements Slic3r::ICloudServiceAgent.

{
    std::lock_guard<std::recursive_mutex> lock(state_mutex);
    enable_track = enable;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS, enable_track, and state_mutex.

track_event()

int Slic3r::OrcaCloudServiceAgent::track_event ( std::string evt_key, std::string content )

overridevirtual

Report a custom analytics event.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: track_event (stub) - " << evt_key;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

track_get_property()

int Slic3r::OrcaCloudServiceAgent::track_get_property ( std::string name, std::string & value, std::string type = "string" )

overridevirtual

Read a tracked user property.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: track_get_property (stub) - " << name;
    value = "";
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

track_header()

int Slic3r::OrcaCloudServiceAgent::track_header ( std::string header )

overridevirtual

Set telemetry headers.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: track_header (stub)";
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

track_remove_files()

int Slic3r::OrcaCloudServiceAgent::track_remove_files ( )

overridevirtual

Delete telemetry files.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: track_remove_files (stub)";
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

track_update_property()

int Slic3r::OrcaCloudServiceAgent::track_update_property ( std::string name, std::string value, std::string type = "string" )

overridevirtual

Update a tracked user property.

Implements Slic3r::ICloudServiceAgent.

{
    BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: track_update_property (stub) - " << name;
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_SUCCESS.

unsubscribe_bundle()

bool Slic3r::OrcaCloudServiceAgent::unsubscribe_bundle

(

const std::string &

bundle_id

)

{
    std::string path = std::string(ORCA_SUBSCRIPTIONS_PATH) + "/" + bundle_id;
    std::string response;
    unsigned int http_code = 0;
 
    int result = http_delete(path, &response, &http_code);
    if (http_code >= 400) {
        return false;
    }
 
    return true;
}

References http_delete().

Here is the call graph for this function:

unsubscribe_plugins()

int Slic3r::OrcaCloudServiceAgent::unsubscribe_plugins

(

const std::vector< std::string > &

plugin_uuids

)

{
    if (plugin_uuids.empty())
        return 0;
 
    std::string response_body;
    unsigned int http_code = 0;
 
    std::string query;
    for (const std::string& plugin_uuid : plugin_uuids) {
        if (plugin_uuid.empty()) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " failed: empty plugin UUID";
            return -1;
        }
 
        if (!query.empty())
            query += ",";
        query += Http::url_encode(plugin_uuid);
    }
 
    const std::string path = std::string(ORCA_UNSUBSCRIBE_PLUGINS) + "?ids=" + query;
    int result             = http_delete(path, &response_body, &http_code);
 
    if (result != 0 || (http_code != 200 && http_code != 204)) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " failed: http_code=" << http_code << ", response=" << response_body;
        return http_code != 0 ? static_cast<int>(http_code) : result;
    }
 
    if (!response_body.empty()) {
        try {
            auto root = json::parse(response_body);
            if (root.contains("not_found") && root["not_found"].is_array() && !root["not_found"].empty()) {
                std::string missing;
                for (const auto& item : root["not_found"]) {
                    if (!item.is_string())
                        continue;
                    if (!missing.empty())
                        missing += ",";
                    missing += item.get<std::string>();
                }
                if (!missing.empty())
                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": plugin UUIDs not found: " << missing;
            }
        } catch (const std::exception& e) {
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": response parse error: " << e.what();
        }
    }
 
    return 0;
}

References http_delete(), and Slic3r::Http::url_encode().

Here is the call graph for this function:

update_redirect_uri()

void Slic3r::OrcaCloudServiceAgent::update_redirect_uri ( )

private

{
    int selected_port         = choose_loopback_port();
    pkce_bundle.loopback_port = selected_port;
    pkce_bundle.redirect      = "http://localhost:" + std::to_string(selected_port) + auth_constants::LOOPBACK_PATH;
}

References Slic3r::auth_constants::LOOPBACK_PATH, and pkce_bundle.

Referenced by OrcaCloudServiceAgent(), and build_login_cmd().

Here is the caller graph for this function:

user_logout()

int Slic3r::OrcaCloudServiceAgent::user_logout ( bool request = false )

overridevirtual

Terminate the current session.

Parameters

request

If true, also notify the backend to invalidate the session.

Implements Slic3r::ICloudServiceAgent.

{
    // Send logout request to backend if requested
    if (request) {
        std::string token;
        std::string refresh_copy;
        {
            std::lock_guard<std::mutex> lock(session_mutex);
            token        = session.access_token;
            refresh_copy = session.refresh_token;
        }
 
        if (!token.empty()) {
            std::string response;
            unsigned int http_code = 0;
            json logout_req        = json::object();
            if (!refresh_copy.empty()) {
                logout_req["refresh_token"] = refresh_copy;
            }
 
            int result = http_post_auth(auth_constants::LOGOUT_PATH, logout_req.dump(), &response, &http_code) ?
                             BAMBU_NETWORK_SUCCESS :
                             BAMBU_NETWORK_ERR_INVALID_HANDLE;
            if (result != BAMBU_NETWORK_SUCCESS || http_code >= 400) {
                BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: Orca cloud logout request failed - http_code=" << http_code;
            }
        }
    }
 
    // An explicit logout also wipes the backend the token storage option is not using, so a token
    // stranded by switching that option cannot sign the account back in later.
    clear_session(/*all_backends=*/request);
    return BAMBU_NETWORK_SUCCESS;
}

References BAMBU_NETWORK_ERR_INVALID_HANDLE, BAMBU_NETWORK_SUCCESS, clear_session(), http_post_auth(), Slic3r::auth_constants::LOGOUT_PATH, session, and session_mutex.

Here is the call graph for this function:

Member Data Documentation

agent_start_epoch

const long long Slic3r::OrcaCloudServiceAgent::agent_start_epoch

private

Initial value:

{std::chrono::duration_cast<std::chrono::seconds>(
                               std::chrono::system_clock::now().time_since_epoch()).count()}

                                            {std::chrono::duration_cast<std::chrono::seconds>(
                               std::chrono::system_clock::now().time_since_epoch()).count()};

Referenced by refresh_session_with_token().

api_base_url

std::string Slic3r::OrcaCloudServiceAgent::api_base_url

private

Referenced by OrcaCloudServiceAgent(), build_login_info(), configure_urls(), get_cloud_service_host(), http_delete(), http_get(), http_post(), http_put(), request_web_session_handoff(), run_health_check(), and set_api_base_url().

auth_base_url

std::string Slic3r::OrcaCloudServiceAgent::auth_base_url

private

Referenced by OrcaCloudServiceAgent(), build_login_cmd(), build_login_info(), configure_urls(), exchange_auth_code(), http_post_auth(), http_post_token(), refresh_session_with_token(), and set_auth_base_url().

auth_headers

std::map<std::string, std::string> Slic3r::OrcaCloudServiceAgent::auth_headers

private

Referenced by OrcaCloudServiceAgent(), build_login_cmd(), configure_urls(), data_headers(), http_post_auth(), and http_post_token().

callback_mutex

std::mutex Slic3r::OrcaCloudServiceAgent::callback_mutex

mutableprivate

cloud_base_url

std::string Slic3r::OrcaCloudServiceAgent::cloud_base_url

private

Referenced by OrcaCloudServiceAgent(), build_web_session_complete_url(), build_web_session_signout_url(), build_web_session_start_url(), configure_urls(), get_bundle_url(), get_cloud_base_url(), get_cloud_login_url(), get_plugin_url(), and set_cloud_base_url().

config_dir

std::string Slic3r::OrcaCloudServiceAgent::config_dir

private

Referenced by set_config_dir(), set_user_session(), and token_lock_path().

country_code

std::string Slic3r::OrcaCloudServiceAgent::country_code

private

Referenced by get_oss_config(), and set_country_code().

enable_track

bool Slic3r::OrcaCloudServiceAgent::enable_track {false}

private

{false};

Referenced by get_track_enable(), and track_enable().

extra_headers

std::map<std::string, std::string> Slic3r::OrcaCloudServiceAgent::extra_headers

private

Referenced by data_headers(), http_post_auth(), and http_post_token().

get_country_code_fn

GetCountryCodeFn Slic3r::OrcaCloudServiceAgent::get_country_code_fn

private

Referenced by set_get_country_code_fn().

headers_mutex

std::mutex Slic3r::OrcaCloudServiceAgent::headers_mutex

mutableprivate

Referenced by data_headers(), http_post_auth(), and http_post_token().

health_check_running

std::atomic_bool Slic3r::OrcaCloudServiceAgent::health_check_running {false}

private

{false};

Referenced by refresh_connection().

health_check_stopped

std::atomic_bool Slic3r::OrcaCloudServiceAgent::health_check_stopped {false}

private

{false};

Referenced by refresh_connection(), and stop_health_check().

health_check_thread

std::thread Slic3r::OrcaCloudServiceAgent::health_check_thread

private

Referenced by refresh_connection(), and stop_health_check().

is_connected

bool Slic3r::OrcaCloudServiceAgent::is_connected {false}

private

{false};

Referenced by is_server_connected(), and run_health_check().

last_refresh_success_epoch

std::atomic<long long> Slic3r::OrcaCloudServiceAgent::last_refresh_success_epoch {0}

private

{0};                 // 0 = no success yet this process

Referenced by refresh_session_with_token().

log_dir

std::string Slic3r::OrcaCloudServiceAgent::log_dir

private

Referenced by OrcaCloudServiceAgent().

m_use_encrypted_token_file

bool Slic3r::OrcaCloudServiceAgent::m_use_encrypted_token_file {false}

private

{false};

Referenced by clear_user_secret(), configure_urls(), get_use_encrypted_token_file(), load_user_secret(), persist_user_secret(), and set_use_encrypted_token_file().

multi_machine_enabled

bool Slic3r::OrcaCloudServiceAgent::multi_machine_enabled {false}

private

{false};

Referenced by enable_multi_machine().

on_http_error_fn

AppOnHttpErrorFn Slic3r::OrcaCloudServiceAgent::on_http_error_fn

private

Referenced by invoke_http_error_callback(), and set_on_http_error_fn().

on_login_complete_handler

OnLoginCompleteHandler Slic3r::OrcaCloudServiceAgent::on_login_complete_handler

private

Referenced by set_on_login_complete_handler(), and set_user_session().

on_server_connected_fn

AppOnServerConnectedFn Slic3r::OrcaCloudServiceAgent::on_server_connected_fn

private

Referenced by invoke_server_connected_callback(), and set_on_server_connected_fn().

pkce_bundle

PkceBundle Slic3r::OrcaCloudServiceAgent::pkce_bundle

private

Referenced by OrcaCloudServiceAgent(), change_user(), exchange_auth_code(), pkce(), regenerate_pkce(), and update_redirect_uri().

queue_on_main_fn

QueueOnMainFn Slic3r::OrcaCloudServiceAgent::queue_on_main_fn

private

Referenced by invoke_http_error_callback(), invoke_server_connected_callback(), and set_queue_on_main_fn().

refresh_running

std::atomic_bool Slic3r::OrcaCloudServiceAgent::refresh_running {false}

private

{false};

Referenced by is_refresh_running(), refresh_if_expiring(), and refresh_now().

refresh_thread

std::thread Slic3r::OrcaCloudServiceAgent::refresh_thread

private

Referenced by ~OrcaCloudServiceAgent(), and refresh_now().

secret_fallback_path

std::string Slic3r::OrcaCloudServiceAgent::secret_fallback_path

private

Referenced by clear_user_secret(), compute_fallback_path(), load_user_secret(), persist_user_secret(), and set_config_dir().

secret_stored

std::atomic_bool Slic3r::OrcaCloudServiceAgent::secret_stored {false}

private

{false};

Referenced by clear_user_secret(), load_user_secret(), and persist_user_secret().

session

SessionInfo Slic3r::OrcaCloudServiceAgent::session

private

Referenced by build_login_info(), build_web_session_start_url(), clear_session(), get_access_token(), get_refresh_token(), get_user_avatar(), get_user_id(), get_user_name(), get_user_nickname(), http_post_auth(), is_user_login(), refresh_session_with_token(), set_user_session(), should_refresh_locked(), and user_logout().

session_handler

SessionHandler Slic3r::OrcaCloudServiceAgent::session_handler

private

Referenced by refresh_session_with_token(), and set_session_handler().

session_mutex

std::mutex Slic3r::OrcaCloudServiceAgent::session_mutex

mutableprivate

Referenced by build_login_info(), build_web_session_start_url(), clear_session(), get_access_token(), get_refresh_token(), get_user_avatar(), get_user_id(), get_user_name(), get_user_nickname(), http_post_auth(), is_user_login(), refresh_if_expiring(), refresh_session_with_token(), set_user_session(), and user_logout().

state_mutex

std::recursive_mutex Slic3r::OrcaCloudServiceAgent::state_mutex

mutableprivate

Referenced by build_login_cmd(), clear_sync_state(), data_headers(), enable_multi_machine(), exchange_auth_code(), get_setting_list2(), get_track_enable(), get_user_presets(), http_post_auth(), http_post_token(), invoke_http_error_callback(), invoke_server_connected_callback(), is_server_connected(), load_sync_state(), run_health_check(), save_sync_state(), set_get_country_code_fn(), set_on_http_error_fn(), set_on_server_connected_fn(), set_queue_on_main_fn(), and track_enable().

sync_state

SyncState Slic3r::OrcaCloudServiceAgent::sync_state

private

Referenced by clear_sync_state(), get_setting_list2(), get_sync_state(), get_user_presets(), load_sync_state(), save_sync_state(), and sync_pull().

sync_state_path

std::string Slic3r::OrcaCloudServiceAgent::sync_state_path

private

Referenced by clear_sync_state(), load_sync_state(), save_sync_state(), and set_user_session().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/OrcaCloudServiceAgent.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/OrcaCloudServiceAgent.cpp