Slic3r::SimplyPrint Class Reference

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

Inheritance diagram for Slic3r::SimplyPrint:

Collaboration diagram for Slic3r::SimplyPrint:

Public Types
typedef Http::ProgressFn	ProgressFn
typedef std::function< void(wxString)>	ErrorFn
typedef std::function< void(wxString, wxString)>	InfoFn

Public Member Functions
	SimplyPrint (DynamicPrintConfig *config)
	~SimplyPrint () override=default
const char *	get_name () const override
bool	can_test () const override
bool	has_auto_discovery () const override
bool	is_cloud () const override
std::string	get_host () const override
GUI::OAuthParams	get_oauth_params () const
void	save_oauth_credential (const GUI::OAuthResult &cred) const
wxString	get_test_ok_msg () const override
wxString	get_test_failed_msg (wxString &msg) const override
bool	test (wxString &curl_msg) const override
PrintHostPostUploadActions	get_post_upload_actions () const override
bool	upload (PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn) const override
bool	is_logged_in () const override
void	log_out () const override
virtual bool	supports_multiple_printers () const
virtual std::string	get_sn () const
virtual bool	get_groups (wxArrayString &) const
virtual bool	get_printers (wxArrayString &) const
virtual bool	get_storage (wxArrayString &, wxArrayString &) const
virtual bool	get_login_url (wxString &auth_url) const

Static Public Member Functions
static PrintHost *	get_print_host (DynamicPrintConfig *config)
static std::string	get_print_host_webui (DynamicPrintConfig *config)
static int	get_err_code_from_body (const std::string &body)

Protected Member Functions
virtual wxString	format_error (const std::string &body, const std::string &error, unsigned status) const

Static Protected Member Functions
static wxString	timed_out_message ()

Private Member Functions
void	load_oauth_credential ()
bool	do_api_call (std::function< Http(bool)> build_request, std::function< bool(std::string, unsigned)> on_complete, std::function< bool(std::string, std::string, unsigned)> on_error) const
	Call the given SimplyPrint API, and if the token expired do a token refresh then retry.
bool	do_temp_upload (const boost::filesystem::path &file_path, const std::string &chunk_id, const std::string &filename, ProgressFn prorgess_fn, ErrorFn error_fn) const
	Upload a temp file and open SimplyPrint panel for file importing.
bool	do_chunk_upload (const boost::filesystem::path &file_path, const std::string &filename, ProgressFn prorgess_fn, ErrorFn error_fn) const

Private Attributes
std::string	cred_file
std::map< std::string, std::string >	cred

Detailed Description

Member Typedef Documentation

ErrorFn

typedef std::function<void(wxString )> Slic3r::PrintHost::ErrorFn

inherited

InfoFn

typedef std::function<void(wxString , wxString )> Slic3r::PrintHost::InfoFn

inherited

ProgressFn

typedef Http::ProgressFn Slic3r::PrintHost::ProgressFn

inherited

Constructor & Destructor Documentation

SimplyPrint()

Slic3r::SimplyPrint::SimplyPrint

(

DynamicPrintConfig *

config

)

{
    cred_file = (boost::filesystem::path(data_dir()) / OAUTH_CREDENTIAL_PATH).make_preferred().string();
    load_oauth_credential();
}

References SimplyPrint(), cred_file, Slic3r::data_dir(), load_oauth_credential(), and Slic3r::OAUTH_CREDENTIAL_PATH.

Referenced by SimplyPrint().

Here is the call graph for this function:

Here is the caller graph for this function:

~SimplyPrint()

Slic3r::SimplyPrint::~SimplyPrint ( )

overridedefault

Member Function Documentation

can_test()

bool Slic3r::SimplyPrint::can_test ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return true; }

do_api_call()

bool Slic3r::SimplyPrint::do_api_call ( std::function< Http(bool)> build_request, std::function< bool(std::string, unsigned)> on_complete, std::function< bool(std::string, std::string, unsigned)> on_error ) const

private

Call the given SimplyPrint API, and if the token expired do a token refresh then retry.

Parameters

build_request	the http request builder
on_complete
on_error

Returns

whether the API call succeeded

{
    if (cred.find("access_token") == cred.end()) {
        return false;
    }
 
    bool res = true;
 
    const auto create_request = [&build_request, &res, &on_complete](const std::string& access_token, bool is_retry) {
        auto http = build_request(is_retry);
        set_auth(http, access_token);
        http.header("User-Agent", "SimplyPrint Orca Plugin")
            .on_complete([&](std::string body, unsigned http_status) {
                res = on_complete(body, http_status);
            });
 
        return http;
    };
 
    create_request(cred.at("access_token"), false)
        .on_error([&res, &on_error, this, &create_request](std::string body, std::string error, unsigned http_status) {
            if (http_status == 401) {
                // Refresh token
                BOOST_LOG_TRIVIAL(warning) << boost::format("SimplyPrint: Access token invalid: %1%, HTTP %2%, body: `%3%`") % error %
                                                  http_status % body;
                BOOST_LOG_TRIVIAL(info) << "SimplyPrint: Attempt to refresh access token";
 
                auto http = Http::post(TOKEN_URL);
                http.timeout_connect(5)
                    .timeout_max(5)
                    .form_add("grant_type", "refresh_token")
                    .form_add("client_id", CLIENT_ID)
                    .form_add("refresh_token", cred.at("refresh_token"))
                    .on_complete([this, &res, &on_error, &create_request](std::string body, unsigned http_status) {
                        GUI::OAuthResult r;
                        GUI::OAuthJob::parse_token_response(body, false, r);
                        if (r.success) {
                            BOOST_LOG_TRIVIAL(info) << "SimplyPrint: Successfully refreshed access token";
                            this->save_oauth_credential(r);
 
                            // Run the api call again
                            create_request(r.access_token, true)
                                .on_error([&res, &on_error](std::string body, std::string error, unsigned http_status) {
                                    res = on_error(body, error, http_status);
                                })
                                .perform_sync();
                        } else {
                            BOOST_LOG_TRIVIAL(error)
                                << boost::format("SimplyPrint: Failed to refresh access token: %1%, body: `%2%`") % r.error_message % body;
                            res = on_error(body, r.error_message, http_status);
                        }
                    })
                    .on_error([&res, &on_error](std::string body, std::string error, unsigned http_status) {
                        BOOST_LOG_TRIVIAL(error)
                            << boost::format("SimplyPrint: Failed to refresh access token: %1%, HTTP %2%, body: `%3%`") % error %
                                   http_status % body;
                        res = on_error(body, error, http_status);
                    })
                    .perform_sync();
            } else {
                res = on_error(body, error, http_status);
            }
        })
        .perform_sync();
 
    return res;
}

References Slic3r::GUI::OAuthResult::access_token, Slic3r::CLIENT_ID, cred, do_api_call(), Slic3r::GUI::OAuthResult::error_message, Slic3r::http, Slic3r::GUI::OAuthJob::parse_token_response(), Slic3r::Http::post(), save_oauth_credential(), Slic3r::set_auth(), Slic3r::GUI::OAuthResult::success, and Slic3r::TOKEN_URL.

Referenced by do_api_call(), do_chunk_upload(), do_temp_upload(), and test().

Here is the call graph for this function:

Here is the caller graph for this function:

do_chunk_upload()

bool Slic3r::SimplyPrint::do_chunk_upload ( const boost::filesystem::path & file_path, const std::string & filename, ProgressFn prorgess_fn, ErrorFn error_fn ) const

private

{
    const auto file_size = boost::filesystem::file_size(file_path);
#ifdef SIMPLYPRINT_TEST
    constexpr auto buffer_size = MAX_SINGLE_UPLOAD_FILE_SIZE;
#else
    constexpr auto buffer_size = MAX_SINGLE_UPLOAD_FILE_SIZE - 1000000;
#endif
 
    const auto chunk_amount = (size_t)ceil((double) file_size / buffer_size);
 
    std::string chunk_id;
    std::string delete_token;
 
    // Tell SimplyPrint that the upload has failed and the chunks should be deleted
    // Note: any error happens here won't be notified to the user
    const auto clean_up = [this, &chunk_id, &delete_token]() {
        if (chunk_id.empty()) {
            // The initial upload failed, do nothing
            BOOST_LOG_TRIVIAL(warning) << "SimplyPrint: Initial chunk upload failed, skip delete";
            return;
        }
 
        assert(!delete_token.empty());
 
        BOOST_LOG_TRIVIAL(info) << boost::format("SimplyPrint: Deleting file chunk %s...") % chunk_id;
        const std::vector<std::pair<std::string, std::string>> query_parameters{
            {"id", chunk_id},
            {"temp", "true"},
            {"delete", delete_token},
        };
        const auto url = (boost::format("%s?%s") % CHUNCK_RECEIVE_URL % url_encode(query_parameters)).str();
        do_api_call(
            [&url](bool is_retry) {
                auto http = Http::get(url);
                return http;
            },
            [&chunk_id](std::string body, unsigned status) {
                BOOST_LOG_TRIVIAL(info) << boost::format("SimplyPrint: File chunk %1% deleted: HTTP %2%: %3%") % chunk_id % status % body;
                return true;
            },
            [&chunk_id](std::string body, std::string error, unsigned status) {
                BOOST_LOG_TRIVIAL(warning) << boost::format("SimplyPrint: Error deleting file chunk %1%: %2%, HTTP %3%, body: `%4%`") %
                                                  chunk_id % error % status % body;
                return false;
            });
    };
 
    // Do chunk upload
    for (size_t i = 0; i < chunk_amount; i++) {
        std::string url;
        {
            std::vector<std::pair<std::string, std::string>> query_parameters{
                {"i", std::to_string(i)},
                {"temp", "true"},
            };
            if (i == 0) {
                query_parameters.emplace_back("filename", filename);
                query_parameters.emplace_back("chunks", std::to_string(chunk_amount));
                query_parameters.emplace_back("totalsize", std::to_string(file_size));
            } else {
                query_parameters.emplace_back("id", chunk_id);
            }
            url = (boost::format("%s?%s") % CHUNCK_RECEIVE_URL % url_encode(query_parameters)).str();
        }
 
        // Calculate the offset and length of current chunk
        const boost::filesystem::ifstream::off_type offset = i * buffer_size;
        const size_t length = i == (chunk_amount - 1) ? file_size - offset : buffer_size;
 
        const bool succ = do_api_call(
            [&url, &file_path, &filename, i, chunk_amount, file_size, offset, length, prorgess_fn](bool is_retry) {
                BOOST_LOG_TRIVIAL(info) << boost::format("SimplyPrint: Start uploading file chunk [%1%/%2%]...") % (i + 1) % chunk_amount;
                auto http = Http::post(url);
                http.form_add_file("file", file_path, filename, offset, length);
 
                http.on_progress([&prorgess_fn, file_size, offset](Http::Progress progress, bool& cancel) {
                    progress.ultotal = file_size;
                    progress.ulnow += offset;
 
                    prorgess_fn(std::move(progress), cancel);
                });
 
                return http;
            },
            [&error_fn, i, chunk_amount, &chunk_id, &delete_token](std::string body, unsigned status) {
                BOOST_LOG_TRIVIAL(info) << boost::format("SimplyPrint: File chunk [%1%/%2%] uploaded: HTTP %3%: %4%") % (i + 1) % chunk_amount % status % body;
                if (i == 0) {
                    // First chunk, parse chunk id
                    const auto j = nlohmann::json::parse(body, nullptr, false, true);
                    if (j.is_discarded()) {
                        BOOST_LOG_TRIVIAL(error) << "SimplyPrint: Invalid or no JSON data on ChunkReceive: " << body;
                        error_fn(_L("Unknown error"));
                        return false;
                    }
 
                    if (j.find("id") == j.end() || j.find("delete_token") == j.end()) {
                        BOOST_LOG_TRIVIAL(error) << "SimplyPrint: Invalid or no JSON data on ChunkReceive: " << body;
                        error_fn(_L("Unknown error"));
                        return false;
                    }
 
                    const unsigned long id = j["id"];
 
                    chunk_id = std::to_string(id);
                    delete_token = j["delete_token"];
                }
                return true;
            },
            [this, &error_fn, i, chunk_amount](std::string body, std::string error, unsigned status) {
                BOOST_LOG_TRIVIAL(error) << boost::format("SimplyPrint: Error uploading file chunk [%1%/%2%]: %3%, HTTP %4%, body: `%5%`") %
                                                (i + 1) % chunk_amount % error % status % body;
                error_fn(format_error(body, error, status));
                return false;
            });
 
        if (!succ) {
            clean_up();
            return false;
        }
    }
 
    assert(!chunk_id.empty());
 
    // Finally, complete the upload using the chunk id
    const bool succ = do_temp_upload({}, chunk_id, filename, prorgess_fn, error_fn);
    if (!succ) {
        clean_up();
    }
 
    return succ;
}

References _L, Slic3r::CHUNCK_RECEIVE_URL, do_api_call(), do_chunk_upload(), do_temp_upload(), Slic3r::PrintHost::format_error(), Slic3r::Http::get(), Slic3r::http, Slic3r::length(), Slic3r::MAX_SINGLE_UPLOAD_FILE_SIZE, Slic3r::offset(), Slic3r::Http::post(), Slic3r::Http::Progress::ulnow, Slic3r::Http::Progress::ultotal, and Slic3r::url_encode().

Referenced by do_chunk_upload(), and upload().

Here is the call graph for this function:

Here is the caller graph for this function:

do_temp_upload()

bool Slic3r::SimplyPrint::do_temp_upload ( const boost::filesystem::path & file_path, const std::string & chunk_id, const std::string & filename, ProgressFn prorgess_fn, ErrorFn error_fn ) const

private

Upload a temp file and open SimplyPrint panel for file importing.

Parameters

file_path	for file smaller than 100MB, this is the file path, otherwise must left empty
chunk_id	for file greater than 100MB, this is the chunk id returned by the ChunkReceive API, otherwise must left empty
filename	the target file name
prorgess_fn
error_fn

Returns

whether upload succeeded

{
    if (file_path.empty() == chunk_id.empty()) {
        BOOST_LOG_TRIVIAL(error) << "SimplyPrint: Invalid arguments: both file_path and chunk_id are set or not provided";
        error_fn(_L("Internal error"));
        return false;
    }
 
    return do_api_call(
        [&file_path, &chunk_id, &prorgess_fn, &filename](bool is_retry) {
            auto http = Http::post(URL_BASE_HOME"/api/files/TempUpload");
            if (!file_path.empty()) {
                http.form_add_file("file", file_path, filename);
            } else {
                http.form_add("chunkId", chunk_id);
            }
            http.on_progress([&prorgess_fn](Http::Progress progress, bool& cancel) { prorgess_fn(std::move(progress), cancel); });
 
            return http;
        },
        [&error_fn, &filename](std::string body, unsigned status) {
            BOOST_LOG_TRIVIAL(info) << boost::format("SimplyPrint: File uploaded: HTTP %1%: %2%") % status % body;
 
            // Get file UUID
            const auto j = nlohmann::json::parse(body, nullptr, false, true);
            if (j.is_discarded()) {
                BOOST_LOG_TRIVIAL(error) << "SimplyPrint: Invalid or no JSON data on token response: " << body;
                error_fn(_L("Unknown error"));
                return false;
            }
 
            if (j.find("uuid") == j.end()) {
                BOOST_LOG_TRIVIAL(error) << "SimplyPrint: Invalid or no JSON data on token response: " << body;
                error_fn(_L("Unknown error"));
                return false;
            }
            const std::string uuid = j["uuid"];
 
            // Launch external browser for file importing after uploading
            const auto url = URL_BASE_HOME"/panel?" + url_encode({{"import", "tmp:" + uuid}, {"filename", filename}});
 
            if (should_open_in_external_browser()) {
                wxLaunchDefaultBrowser(url);
            } else {
                // The tab switch queues a reload of the printer's home page, so switch synchronously
                // first and queue the import page after it.
                GUI::wxGetApp().CallAfter([url = wxString::FromUTF8(url)] {
                    const auto mainframe = GUI::wxGetApp().mainframe;
                    mainframe->select_tab(TAB_ID_MONITOR);
                    mainframe->load_printer_url(url);
                });
            }
 
            return true;
        },
        [this, &error_fn](std::string body, std::string error, unsigned status) {
            BOOST_LOG_TRIVIAL(error) << boost::format("SimplyPrint: Error uploading file : %1%, HTTP %2%, body: `%3%`") % error % status % body;
            error_fn(format_error(body, error, status));
            return false;
        });
}

References _L, do_api_call(), do_temp_upload(), Slic3r::PrintHost::format_error(), Slic3r::http, Slic3r::Http::post(), Slic3r::should_open_in_external_browser(), TAB_ID_MONITOR, URL_BASE_HOME, and Slic3r::url_encode().

Referenced by do_chunk_upload(), do_temp_upload(), and upload().

Here is the call graph for this function:

Here is the caller graph for this function:

format_error()

wxString Slic3r::PrintHost::format_error ( const std::string & body, const std::string & error, unsigned status ) const

protectedvirtualinherited

{
    if (status != 0) {
        const std::string reason = moonraker_error_reason(body);
        auto wxbody = wxString::FromUTF8(reason.empty() ? body : reason);
        return wxString::Format("HTTP %u: %s", status, wxbody);
    } else {
        if (error.find("curl:Timeout was reached") != std::string::npos) {
            return timed_out_message();
        }else if(error.find("curl:Couldn't resolve host name")!= std::string::npos){
            return _L("The Hostname/IP/URL could not be parsed, please check it and try again.");
        } else if (error.find("Connection was reset") != std::string::npos){
            return _L("File/data transfer interrupted. Please check the printer and network, then try it again.");
        }
        else {
            return wxString::FromUTF8(error.data());
        }
    }
}

References _L, and timed_out_message().

Referenced by Slic3r::Duet::connect(), Slic3r::UltiMaker::connect(), Slic3r::SimplyPrint::do_chunk_upload(), Slic3r::SimplyPrint::do_temp_upload(), Slic3r::ElegooLink::elegoo_cc2_test(), Slic3r::ElegooLink::elegoo_test(), Slic3r::PrusaLink::post_inner(), Slic3r::PrusaLink::put_inner(), Slic3r::Flashforge::request_local_api_json(), Slic3r::Duet::start_print(), Slic3r::Moonraker::start_print(), Slic3r::UltiMaker::start_print(), Slic3r::AstroBox::test(), Slic3r::CrealityPrint::test(), Slic3r::ESP3D::test(), Slic3r::FlashAir::test(), Slic3r::Moonraker::test(), Slic3r::Obico::test(), Slic3r::OctoPrint::test(), Slic3r::PrusaLink::test(), Slic3r::Repetier::test(), Slic3r::UltiMaker::test(), Slic3r::PrusaLink::test_with_method_check(), Slic3r::AstroBox::upload(), Slic3r::C3DPrinterOS::upload(), Slic3r::CrealityPrint::upload(), Slic3r::Duet::upload(), Slic3r::ESP3D::upload(), Slic3r::FlashAir::upload(), Slic3r::MKS::upload(), Slic3r::Moonraker::upload(), Slic3r::Obico::upload(), Slic3r::Repetier::upload(), Slic3r::UltiMaker::upload(), Slic3r::OctoPrint::upload_inner_with_host(), Slic3r::Flashforge::upload_local_api(), Slic3r::ElegooLink::uploadPart(), and Slic3r::ElegooLink::uploadPartCC2().

Here is the call graph for this function:

Here is the caller graph for this function:

get_err_code_from_body()

int Slic3r::PrintHost::get_err_code_from_body ( const std::string & body )

staticinherited

{
    boost::property_tree::ptree root;
    std::istringstream iss(body);
    try {
        boost::property_tree::read_json(iss, root);
    } catch (const std::exception &ex) {
        BOOST_LOG_TRIVIAL(error) << "PrintHost: response is not valid JSON: " << ex.what();
        return -1;
    }
 
    return root.get<int>("err", 0);
}

Referenced by Slic3r::Duet::connect(), Slic3r::UltiMaker::connect(), Slic3r::Duet::upload(), Slic3r::MKS::upload(), and Slic3r::UltiMaker::upload().

Here is the caller graph for this function:

get_groups()

virtual bool Slic3r::PrintHost::get_groups ( wxArrayString & ) const

inlinevirtualinherited

Reimplemented in Slic3r::Repetier.

{ return false; }

get_host()

std::string Slic3r::SimplyPrint::get_host ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return "https://simplyprint.io"; }

get_login_url()

virtual bool Slic3r::PrintHost::get_login_url ( wxString & auth_url ) const

inlinevirtualinherited

Reimplemented in Slic3r::Obico.

{ return false; }

Referenced by Slic3r::GUI::PrinterCloudAuthDialog::PrinterCloudAuthDialog().

Here is the caller graph for this function:

get_name()

const char * Slic3r::SimplyPrint::get_name ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return "SimplyPrint"; }

get_oauth_params()

GUI::OAuthParams Slic3r::SimplyPrint::get_oauth_params

(

)

const

{
    const auto verification_code = generate_verification_code();
    // SimplyPrint uses S256 for PKCE
    const auto code_challenge = sha256b64(verification_code);
    const auto state          = generate_verification_code();
 
    const std::vector<std::pair<std::string, std::string>> query_parameters{
        {"client_id", CLIENT_ID},
        {"redirect_uri", CALLBACK_URL},
        {"scope", CLIENT_SCOPES},
        {"response_type", RESPONSE_TYPE},
        {"state", state},
        {"code_challenge", code_challenge},
        {"code_challenge_method", "S256"},
    };
    const auto login_url = (boost::format(URL_BASE_HOME"/panel/oauth2/authorize?%s") % url_encode(query_parameters)).str();
 
    return GUI::OAuthParams{
        login_url,
        CLIENT_ID,
        CALLBACK_PORT,
        CALLBACK_URL,
        CLIENT_SCOPES,
        RESPONSE_TYPE,
        URL_BASE_HOME"/login-success",
        URL_BASE_HOME"/login-success",
        TOKEN_URL,
        verification_code,
        state,
    };
}

References Slic3r::CALLBACK_PORT, Slic3r::CALLBACK_URL, Slic3r::CLIENT_ID, Slic3r::CLIENT_SCOPES, Slic3r::generate_verification_code(), get_oauth_params(), Slic3r::RESPONSE_TYPE, Slic3r::sha256b64(), Slic3r::TOKEN_URL, URL_BASE_HOME, and Slic3r::url_encode().

Referenced by get_oauth_params().

Here is the call graph for this function:

Here is the caller graph for this function:

get_post_upload_actions()

PrintHostPostUploadActions Slic3r::SimplyPrint::get_post_upload_actions ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return PrintHostPostUploadAction::QueuePrint; }

References Slic3r::QueuePrint.

get_print_host()

PrintHost * Slic3r::PrintHost::get_print_host ( DynamicPrintConfig * config )

staticinherited

{
    PrinterTechnology tech = ptFFF;
 
    {
        const auto opt = config->option<ConfigOptionEnum<PrinterTechnology>>("printer_technology");
        if (opt != nullptr) {
            tech = opt->value;
        }
    }
 
    if (tech == ptFFF) {
        const auto opt = config->option<ConfigOptionEnum<PrintHostType>>("host_type");
        const auto host_type = opt != nullptr ? opt->value : htOctoPrint;
 
        switch (host_type) {
            case htOctoPrint: return new OctoPrint(config);
            case htDuet:      return new Duet(config);
            case htUltiMaker: return new UltiMaker(config);
            case htFlashAir:  return new FlashAir(config);
            case htAstroBox:  return new AstroBox(config);
            case htRepetier:  return new Repetier(config);
            case htPrusaLink: return new PrusaLink(config);
            case htPrusaConnect: return new PrusaConnect(config);
            case htMKS:       return new MKS(config);
            case htESP3D:       return new ESP3D(config);
            case htCrealityPrint:    return new CrealityPrint(config);
            case htObico:     return new Obico(config);
            case htFlashforge: return new Flashforge(config);
            case htSimplyPrint: return new SimplyPrint(config);
            case htElegooLink: return new ElegooLink(config);
            case ht3DPrinterOS: return new C3DPrinterOS(config);
            case htMoonraker: return new Moonraker(config);
            default:          return nullptr;
        }
    } else {
        return new SL1Host(config);
    }
}

References Slic3r::ht3DPrinterOS, Slic3r::htAstroBox, Slic3r::htCrealityPrint, Slic3r::htDuet, Slic3r::htElegooLink, Slic3r::htESP3D, Slic3r::htFlashAir, Slic3r::htFlashforge, Slic3r::htMKS, Slic3r::htMoonraker, Slic3r::htObico, Slic3r::htOctoPrint, Slic3r::htPrusaConnect, Slic3r::htPrusaLink, Slic3r::htRepetier, Slic3r::htSimplyPrint, Slic3r::htUltiMaker, Slic3r::ConfigBase::option(), and Slic3r::ptFFF.

Referenced by Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings(), Slic3r::GUI::anonymous_namespace{PrinterWebViewHandler.cpp}::ElegooPrinterWebViewHandler::handle_get_sn_request(), Slic3r::GUI::anonymous_namespace{PrinterWebViewHandler.cpp}::ElegooPrinterWebViewHandler::handle_upload_request(), Slic3r::GUI::PhysicalPrinterDialog::update_printers(), and Slic3r::GUI::PhysicalPrinterDialog::update_printhost_buttons().

Here is the call graph for this function:

Here is the caller graph for this function:

get_print_host_webui()

std::string Slic3r::PrintHost::get_print_host_webui ( DynamicPrintConfig * config )

staticinherited

{
    if (config == nullptr)
        return {};
 
    std::string webui_url;
    const auto* host_type_opt = config->option<ConfigOptionEnum<PrintHostType>>("host_type");
    const auto  host_type     = host_type_opt != nullptr ? host_type_opt->value : htOctoPrint;
 
    switch (host_type) {
    case htElegooLink: {
        webui_url = ElegooLink::get_print_host_webui(config);
        break;
    }
    default: break;
    }
 
    if (webui_url.empty()) {
        webui_url = config->opt_string("print_host_webui");
        if (webui_url.empty())
            webui_url = config->opt_string("print_host");
        if (webui_url.empty())
            return webui_url;
    }
 
    const bool has_http_scheme = boost::algorithm::istarts_with(webui_url, "http");
    const bool has_file_scheme = boost::algorithm::istarts_with(webui_url, "file:");
 
    if (!has_http_scheme && !has_file_scheme)
        webui_url = "http://" + webui_url;
 
    return webui_url;
}

References Slic3r::ElegooLink::get_print_host_webui(), Slic3r::htElegooLink, Slic3r::htOctoPrint, Slic3r::DynamicConfig::opt_string(), Slic3r::ConfigBase::option(), and Slic3r::ConfigOptionSingle< T >::value.

Referenced by Slic3r::GUI::MainFrame::load_printer_url(), Slic3r::GUI::Plater::priv::on_tab_selection_changing(), and Slic3r::GUI::Sidebar::update_all_preset_comboboxes().

Here is the call graph for this function:

Here is the caller graph for this function:

get_printers()

virtual bool Slic3r::PrintHost::get_printers ( wxArrayString & ) const

inlinevirtualinherited

Reimplemented in Slic3r::Obico, and Slic3r::Repetier.

{ return false; }

get_sn()

virtual std::string Slic3r::PrintHost::get_sn ( ) const

inlinevirtualinherited

Get the serial number for connecting to the printer. For Elegoo CC2, the device details connection to the printer requires the serial number. Other print hosts do not need to implement this interface, and it returns an empty string by default.

Reimplemented in Slic3r::ElegooLink.

{ return ""; }

get_storage()

virtual bool Slic3r::PrintHost::get_storage ( wxArrayString & , wxArrayString &  ) const

inlinevirtualinherited

Reimplemented in Slic3r::Moonraker, Slic3r::PrusaConnect, and Slic3r::PrusaLink.

{ return false; }

get_test_failed_msg()

wxString Slic3r::SimplyPrint::get_test_failed_msg ( wxString & msg ) const

overridevirtual

Implements Slic3r::PrintHost.

{
    return GUI::format_wxstr("%s: %s", _L("Could not connect to SimplyPrint"), msg.Truncate(256));
}

References _L, Slic3r::GUI::format_wxstr(), and get_test_failed_msg().

Referenced by get_test_failed_msg().

Here is the call graph for this function:

Here is the caller graph for this function:

get_test_ok_msg()

wxString Slic3r::SimplyPrint::get_test_ok_msg ( ) const

overridevirtual

Implements Slic3r::PrintHost.

{ return _(L("Connected to SimplyPrint successfully!")); }

References _, get_test_ok_msg(), and L.

Referenced by get_test_ok_msg().

Here is the call graph for this function:

Here is the caller graph for this function:

has_auto_discovery()

bool Slic3r::SimplyPrint::has_auto_discovery ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return false; }

is_cloud()

bool Slic3r::SimplyPrint::is_cloud ( ) const

inlineoverridevirtual

Reimplemented from Slic3r::PrintHost.

{ return true; }

is_logged_in()

bool Slic3r::SimplyPrint::is_logged_in ( ) const

inlineoverridevirtual

Reimplemented from Slic3r::PrintHost.

{ return !cred.empty(); }

References cred.

load_oauth_credential()

void Slic3r::SimplyPrint::load_oauth_credential ( )

private

{
    cred.clear();
    if (boost::filesystem::exists(cred_file)) {
        nlohmann::json j;
        try {
            boost::nowide::ifstream ifs(cred_file);
            ifs >> j;
            ifs.close();
 
            cred["access_token"] = j["access_token"];
            cred["refresh_token"] = j["refresh_token"];
        } catch (std::exception& err) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": parse " << cred_file << " failed, reason = " << err.what();
            cred.clear();
        }
    }
}

References cred, cred_file, and load_oauth_credential().

Referenced by SimplyPrint(), and load_oauth_credential().

Here is the call graph for this function:

Here is the caller graph for this function:

log_out()

void Slic3r::SimplyPrint::log_out ( ) const

overridevirtual

Reimplemented from Slic3r::PrintHost.

{
    boost::nowide::remove(cred_file.c_str());
}

References cred_file, and log_out().

Referenced by log_out().

Here is the call graph for this function:

Here is the caller graph for this function:

save_oauth_credential()

void Slic3r::SimplyPrint::save_oauth_credential

(

const GUI::OAuthResult &

cred

)

const

{
    nlohmann::json j;
    j["access_token"]  = cred.access_token;
    j["refresh_token"] = cred.refresh_token;
    
    boost::nowide::ofstream c;
    c.open(cred_file, std::ios::out | std::ios::trunc);
    c << j.dump(1, '\t') << std::endl;
    c.close();
}

References cred, cred_file, and save_oauth_credential().

Referenced by do_api_call(), and save_oauth_credential().

Here is the call graph for this function:

Here is the caller graph for this function:

supports_multiple_printers()

virtual bool Slic3r::PrintHost::supports_multiple_printers ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::Repetier.

{ return false; }

test()

bool Slic3r::SimplyPrint::test ( wxString & curl_msg ) const

overridevirtual

Implements Slic3r::PrintHost.

{
    if (cred.find("access_token") == cred.end()) {
        return false;
    }
 
    return do_api_call(
        [](bool is_retry) {
            auto http = Http::get(URL_BASE_API"/oauth2/TokenInfo");
            http.header("Accept", "application/json");
            return http;
        },
        [](std::string body, unsigned) {
            BOOST_LOG_TRIVIAL(info) << boost::format("SimplyPrint: Got token info: %1%") % body;
            return true;
        },
        [](std::string body, std::string error, unsigned status) {
            BOOST_LOG_TRIVIAL(error) << boost::format("SimplyPrint: Error getting token info: %1%, HTTP %2%, body: `%3%`") % error %
                                            status % body;
            return false;
        });
}

References cred, do_api_call(), Slic3r::Http::get(), Slic3r::http, test(), and URL_BASE_API.

Referenced by test().

Here is the call graph for this function:

Here is the caller graph for this function:

timed_out_message()

wxString Slic3r::PrintHost::timed_out_message ( )

staticprotectedinherited

{
    return _L("Connection timed out. Please check if the printer and computer network are functioning properly, and confirm that they are on the same network.");
}

References _L.

Referenced by format_error(), and Slic3r::CrealityPrint::start_print().

Here is the caller graph for this function:

upload()

bool Slic3r::SimplyPrint::upload ( PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn ) const

overridevirtual

Implements Slic3r::PrintHost.

{
    if (cred.find("access_token") == cred.end()) {
        error_fn(_L("SimplyPrint account not linked. Go to Connect options to set it up."));
        return false;
    }
    const auto filename = upload_data.upload_path.filename().string();
 
    if (boost::filesystem::file_size(upload_data.source_path) > MAX_SINGLE_UPLOAD_FILE_SIZE) {
        // If file is over 100 MB, do chunk upload
        return do_chunk_upload(upload_data.source_path, filename, prorgess_fn, error_fn);
    } else {
        // Normal upload
        return do_temp_upload(upload_data.source_path, {}, filename, prorgess_fn, error_fn);
    }
}

References _L, cred, do_chunk_upload(), do_temp_upload(), Slic3r::MAX_SINGLE_UPLOAD_FILE_SIZE, Slic3r::PrintHostUpload::source_path, upload(), and Slic3r::PrintHostUpload::upload_path.

Referenced by upload().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

cred

std::map<std::string, std::string> Slic3r::SimplyPrint::cred

private

Referenced by do_api_call(), is_logged_in(), load_oauth_credential(), save_oauth_credential(), test(), and upload().

cred_file

std::string Slic3r::SimplyPrint::cred_file

private

Referenced by SimplyPrint(), load_oauth_credential(), log_out(), and save_oauth_credential().

---

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

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