Slic3r::C3DPrinterOS Class Reference

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

Inheritance diagram for Slic3r::C3DPrinterOS:

Collaboration diagram for Slic3r::C3DPrinterOS:

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

Public Member Functions
	C3DPrinterOS (DynamicPrintConfig *config)
	~C3DPrinterOS () override=default
const char *	get_name () const override
bool	test (wxString &curl_msg) const override
bool	login (wxString &msg) const
wxString	get_test_ok_msg () const override
wxString	get_test_failed_msg (wxString &msg) const override
bool	upload (PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn) const override
bool	has_auto_discovery () const override
bool	can_test () const override
bool	is_cloud () const override
void	log_out () const override
bool	is_logged_in () const override
PrintHostPostUploadActions	get_post_upload_actions () const override
std::string	get_host () 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 std::string	default_host ()
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
bool	validate_version_text (const boost::optional< std::string > &version_text) const
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_api_session ()
bool	save_api_session (const std::string &session, const std::string &email) const
std::string	parse_printer_model (const std::string &input) const
std::string	make_url (const std::string &path) const
std::string	get_api_auth_token (wxString &err) const
void	login_with_token (boost::property_tree::ptree &resp, const std::string &token) const
bool	check_session (wxString &msg) const
void	send_form (const std::string &endpoint, const std::string &postBody, boost::property_tree::ptree &responseTree) const
void	get_cloud_projects_list (boost::property_tree::ptree &response) const
void	get_cloud_printer_types (boost::property_tree::ptree &response, const std::string &querry) const
void	update_file (boost::property_tree::ptree &response, const std::string &file_id, const std::string &ptype, const std::string &gtype) const

Private Attributes
std::string	m_host
std::string	m_apikey
std::string	m_cafile
std::string	m_username
std::string	m_host_type
std::string	m_preset_name
std::string	m_api_session_file_path

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

C3DPrinterOS()

Slic3r::C3DPrinterOS::C3DPrinterOS

(

DynamicPrintConfig *

config

)

    : m_host(config->opt_string("print_host"))
    , m_apikey(config->opt_string("printhost_apikey"))
    , m_preset_name(config->opt_string("printer_model"))
{
    m_api_session_file_path = (boost::filesystem::path(Slic3r::data_dir()) / API_CREDENTIALS_PATH)
                                  .make_preferred()
                                  .string();
    load_api_session();
}

References Slic3r::API_CREDENTIALS_PATH, Slic3r::data_dir(), load_api_session(), m_api_session_file_path, m_apikey, m_host, and m_preset_name.

Here is the call graph for this function:

~C3DPrinterOS()

Slic3r::C3DPrinterOS::~C3DPrinterOS ( )

overridedefault

Member Function Documentation

can_test()

bool Slic3r::C3DPrinterOS::can_test ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return true; }

check_session()

bool Slic3r::C3DPrinterOS::check_session ( wxString & msg ) const

private

                                                    {
    std::string postBody = "session=" + m_apikey;
    pt::ptree resp;
    send_form("apiglobal/check_session", postBody, resp);
    try {
        if (resp.get<bool>("result")) {
            return true;
        } else {
            msg = wxString::FromUTF8(resp.get<std::string>("message"));
            return false;
        }
 
    } catch (const std::exception &) {
        msg = _L("Could not parse server response.");
        return false;
    }
    return false;
}

References _L, m_apikey, and send_form().

Referenced by test(), and upload().

Here is the call graph for this function:

Here is the caller graph for this function:

default_host()

std::string Slic3r::C3DPrinterOS::default_host ( )

inlinestatic

{ return "https://cloud.3dprinteros.com"; }

Referenced by Slic3r::GUI::PhysicalPrinterDialog::update().

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_api_auth_token()

std::string Slic3r::C3DPrinterOS::get_api_auth_token ( wxString & err ) const

private

{
    std::string result;
    pt::ptree resp;
    std::string postBody = "app_type=plugin&app_name=" + Http::url_encode("OrcaSlicer");
    send_form("apiglobal/generate_login_token", postBody, resp);
    try {
        if (resp.get<bool>("result")) {
            result = resp.get<std::string>("message");
        } else {
            err = wxString::FromUTF8(resp.get<std::string>("message"));
        }
    } catch (const std::exception &) {
        err = _L("Could not parse server response.");
    }
    return result;
}

References _L, send_form(), and Slic3r::Http::url_encode().

Referenced by login().

Here is the call graph for this function:

Here is the caller graph for this function:

get_cloud_printer_types()

void Slic3r::C3DPrinterOS::get_cloud_printer_types ( boost::property_tree::ptree & response, const std::string & querry ) const

private

{
    std::string postBody = std::string("session=" + m_apikey);
    if (!query.empty()) {
        postBody += "&description=" + Http::url_encode(query) + "&software_version=" + Http::url_encode("OrcaSlicer");
    }
    send_form("apiglobal/get_printer_types", postBody, response);
}

References m_apikey, send_form(), and Slic3r::Http::url_encode().

Referenced by upload().

Here is the call graph for this function:

Here is the caller graph for this function:

get_cloud_projects_list()

void Slic3r::C3DPrinterOS::get_cloud_projects_list ( boost::property_tree::ptree & response ) const

private

{
    std::string postBody = std::string("session=" + m_apikey);
    send_form("apiglobal/get_projects", postBody, response);
}

References m_apikey, and send_form().

Referenced by upload().

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::C3DPrinterOS::get_host ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return m_host; }

References m_host.

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::C3DPrinterOS::get_name ( ) const

overridevirtual

Implements Slic3r::PrintHost.

{ return "3DPrinterOS"; }

Referenced by upload().

Here is the caller graph for this function:

get_post_upload_actions()

PrintHostPostUploadActions Slic3r::C3DPrinterOS::get_post_upload_actions ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return PrintHostPostUploadAction::StartPrint | PrintHostPostUploadAction::QueuePrint; }

References Slic3r::QueuePrint, and Slic3r::StartPrint.

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::C3DPrinterOS::get_test_failed_msg ( wxString & msg ) const

overridevirtual

Implements Slic3r::PrintHost.

{
    return GUI::format_wxstr("%s: %s\n\n", _L("Error session check"), msg);
}

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

Here is the call graph for this function:

get_test_ok_msg()

wxString Slic3r::C3DPrinterOS::get_test_ok_msg ( ) const

overridevirtual

Implements Slic3r::PrintHost.

{
    wxString msg = _L("Connection to 3DPrinterOS cloud works correctly.");
    if (!m_username.empty())
        // TRN %1% is the 3DPrinterOS account (e-mail address).
        msg += " " + GUI::format_wxstr(_L("Logged in as user: %1%"), m_username);
    return msg;
}

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

Here is the call graph for this function:

has_auto_discovery()

bool Slic3r::C3DPrinterOS::has_auto_discovery ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return false; }

is_cloud()

bool Slic3r::C3DPrinterOS::is_cloud ( ) const

inlineoverridevirtual

Reimplemented from Slic3r::PrintHost.

{ return true; }

is_logged_in()

bool Slic3r::C3DPrinterOS::is_logged_in ( ) const

inlineoverridevirtual

Reimplemented from Slic3r::PrintHost.

{ return !m_apikey.empty(); }

References m_apikey.

load_api_session()

void Slic3r::C3DPrinterOS::load_api_session ( )

private

{
    m_apikey.clear();
    if (boost::filesystem::exists(m_api_session_file_path)) {
        pt::ptree j;
        try {
            pt::read_json(m_api_session_file_path, j);
            m_apikey = j.get<std::string>("session");
            m_username = j.get<std::string>("email");
        } catch (const std::exception &err) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": load_api_session failed, reason = " << err.what();
            // remove corrupted file to avoid repeated failures
            try {
                boost::filesystem::remove(m_api_session_file_path);
            } catch (...) {}
        }
    };
}

References m_api_session_file_path, m_apikey, and m_username.

Referenced by C3DPrinterOS().

Here is the caller graph for this function:

log_out()

void Slic3r::C3DPrinterOS::log_out ( ) const

overridevirtual

Reimplemented from Slic3r::PrintHost.

{ 
    boost::filesystem::remove(m_api_session_file_path.c_str());
}

References m_api_session_file_path.

login()

bool Slic3r::C3DPrinterOS::login

(

wxString &

msg

)

const

{
    // Get token for auth
    msg.clear();
    std::string token = get_api_auth_token(msg);
    if (token.empty()) {
        msg = _L("Error. Can't get API token for authorization");
        return false;
    }
 
    auto login_url = make_url("noauth/apiglobal_login_with_token/" + token);
    wxLaunchDefaultBrowser(login_url);
    pt::ptree login_resp;
    login_with_token(login_resp, token);
    std::string session, email;
    try {
        if (login_resp.get<bool>("result")) {
            session = login_resp.get<std::string>("message.session");
            email   = login_resp.get<std::string>("message.email");
        } else {
            msg = wxString::FromUTF8(login_resp.get<std::string>("message"));
            return false;
        }
    } catch (const std::exception&) {
        msg = _L("Could not parse server response.");
        return false;
    }
    bool res = save_api_session(session, email);
    if (!res) {
        msg = _L("Error saving session to file");
    }
    return res;
}

References _L, get_api_auth_token(), login_with_token(), make_url(), and save_api_session().

Here is the call graph for this function:

login_with_token()

void Slic3r::C3DPrinterOS::login_with_token ( boost::property_tree::ptree & resp, const std::string & token ) const

private

                                                                               {
    auto url = make_url("apiglobal/login_with_token");
    TokenAuthDialog dlg(GUI::wxGetApp().GetTopWindow(), url, token, m_cafile, resp);
    dlg.ShowModal();
}

References m_cafile, and make_url().

Referenced by login().

Here is the call graph for this function:

Here is the caller graph for this function:

make_url()

std::string Slic3r::C3DPrinterOS::make_url ( const std::string & path ) const

private

{
    if (m_host.find("http://") == 0 || m_host.find("https://") == 0) {
        if (m_host.back() == '/') {
            return (boost::format("%1%%2%") % m_host % path).str();
        } else {
            return (boost::format("%1%/%2%") % m_host % path).str();
        }
    } else {
        return (boost::format("https://%1%/%2%") % m_host % path).str();
    }
}

References m_host.

Referenced by login(), login_with_token(), send_form(), and upload().

Here is the caller graph for this function:

parse_printer_model()

std::string Slic3r::C3DPrinterOS::parse_printer_model ( const std::string & input ) const

private

save_api_session()

bool Slic3r::C3DPrinterOS::save_api_session ( const std::string & session, const std::string & email ) const

private

                                                                                          {
    pt::ptree j;
    j.put("session", session);
    j.put("email", email);
    try {
        std::ostringstream json;
        pt::write_json(json, j);
        if (const std::error_code ec = write_file_atomically(m_api_session_file_path, json.str()))
            throw std::system_error(ec);
    } catch (const std::exception &err) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": failed to write json to file. Path = "
                                 << m_api_session_file_path
                                 << " Reason = " << err.what();
        return false;
    }
    return true;
}

References m_api_session_file_path, and Slic3r::write_file_atomically().

Referenced by login().

Here is the call graph for this function:

Here is the caller graph for this function:

send_form()

void Slic3r::C3DPrinterOS::send_form ( const std::string & endpoint, const std::string & postBody, boost::property_tree::ptree & responseTree ) const

private

{
    responseTree.clear();
    auto url = make_url(endpoint);
    auto http = Http::post(std::move(url));
    if (!m_cafile.empty()) {
        http.ca_file(m_cafile);
    }
    http.header("Content-length", std::to_string(postBody.size()));
    http.set_post_body(postBody);
    http.on_error([&](std::string body, std::string error, unsigned status) {
            BOOST_LOG_TRIVIAL(error) << boost::format("Error sending form: %1%") % error;
            responseTree.put("result", false);
            responseTree.put("message", error);
        })
        .on_complete([&](std::string body, unsigned) {
            std::stringstream ss(body);
            try {
                pt::read_json(ss, responseTree);
            } catch (const std::exception &) {
                responseTree.put("result", false);
                responseTree.put("message", _u8L("Could not parse server response."));
            }
        })
        .perform_sync();
}

References _u8L, Slic3r::http, m_cafile, make_url(), and Slic3r::Http::post().

Referenced by check_session(), get_api_auth_token(), get_cloud_printer_types(), get_cloud_projects_list(), and update_file().

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::C3DPrinterOS::test ( wxString & curl_msg ) const

overridevirtual

Implements Slic3r::PrintHost.

{
    return check_session(msg);
}

References check_session().

Here is the call 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:

update_file()

void Slic3r::C3DPrinterOS::update_file ( boost::property_tree::ptree & response, const std::string & file_id, const std::string & ptype, const std::string & gtype ) const

private

{
    std::string postBody = "session=" + m_apikey 
        + "&updates[" + file_id + "][ptype]=" + ptype
        + "&updates[" + file_id + "][gtype]=" + Http::url_encode(gtype) 
        + "&updates[" + file_id + "][zip]=false";
    send_form("apiglobal/file_update", postBody, response);
}

References m_apikey, send_form(), and Slic3r::Http::url_encode().

Referenced by upload().

Here is the call graph for this function:

Here is the caller graph for this function:

upload()

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

overridevirtual

Implements Slic3r::PrintHost.

{
    const char *name = get_name();
    const auto upload_filename = upload_data.upload_path.filename();
    const auto upload_parent_path = upload_data.upload_path.parent_path();
    wxString test_msg;
    if (!check_session(test_msg)) {
        error_fn(std::move(test_msg));
        return false;
    }
 
    pt::ptree cloud_project_resp;
    pt::ptree cloud_printer_types_resp;
 
    get_cloud_projects_list(cloud_project_resp);
    get_cloud_printer_types(cloud_printer_types_resp, m_preset_name);
    wxArrayString cloud_projects_list;
    wxArrayString cloud_printer_types_list;
 
    try {
        if (cloud_project_resp.get<bool>("result")) {
            for (const auto &messageItem : cloud_project_resp.get_child("message")) {
                cloud_projects_list.Add(messageItem.second.get<std::string>("name"));
            }
        }
 
        if (cloud_printer_types_resp.get<bool>("result")) {
            for (const auto &messageItem : cloud_printer_types_resp.get_child("message")) {
                cloud_printer_types_list.Add(messageItem.second.get<std::string>("description"));
            }
        }
    } catch (const std::exception &) {
        error_fn(_L("Could not parse server response."));
        return false;
    }
    
    // Show "Confirm cloud printer type and project for 3DPrinterOS upload
    
    UploadOptionsDialog dlg(GUI::wxGetApp().GetTopWindow(), cloud_projects_list, cloud_printer_types_list, m_preset_name);
 
    if (dlg.ShowModal() != wxID_OK) {
        error_fn(_L("Canceled"));
        return false;
    }
    
    std::string selected_project;
    std::string selected_printer_type;
    dlg.GetValues(selected_project, selected_printer_type);
    std::string project_id;
    std::string printer_type_id;
 
    // search for cloud project_id by name
    if (!selected_project.empty()) {
        for (const auto& messageItem : cloud_project_resp.get_child("message")) {
            if (messageItem.second.get<std::string>("name", "") == selected_project) {
                project_id = messageItem.second.get<std::string>("id", "");
                break;
            }
        }
    }
 
    // search for cloud printer_type_id by name
    for (const auto& messageItem : cloud_printer_types_resp.get_child("message")) {
        if (messageItem.second.get<std::string>("description", "") == selected_printer_type) {
            printer_type_id = messageItem.second.get<std::string>("id", "");
            break;
        }
    }
 
    bool res = true;
    auto url = make_url("apiglobal/upload");
    std::string file_id;
    pt::ptree uploadResponse;
    auto http = Http::post(std::move(url));
    if (!m_cafile.empty()) {
        http.ca_file(m_cafile);
    }
    http.form_add("session", m_apikey)
        .form_add("upload_type_id", "7")
        .form_add("upload_soft_name", "OrcaSlicer")
        .form_add("zip", "false")
        .form_add_file("file", upload_data.source_path.string(), upload_filename.string());
 
    if (!project_id.empty()) {
        http.form_add("project_id", project_id);
    } else if (!selected_project.empty()) {
        http.form_add("project_name", selected_project);
        http.form_add("project_color", "grey");
    }
 
    http.on_complete([&](std::string body, unsigned status) {
            std::stringstream ss(body);
            try {
                pt::read_json(ss, uploadResponse);
            } catch (const std::exception &) {
                uploadResponse.put("result", false);
                uploadResponse.put("message", _u8L("Could not parse server response."));
            }
        })
        .on_error([&](std::string body, std::string error, unsigned status) {
            error_fn(format_error(body, error, status));
            res = false;
        })
        .on_progress([&](Http::Progress progress, bool &cancel) {
            prorgess_fn(std::move(progress), cancel);
            if (cancel) {
                res = false;
            }
        })
        .perform_sync();
 
    try {
        if (uploadResponse.get<bool>("result")) {
            file_id = uploadResponse.get<std::string>("message.file_id");
        } else {
            res = false;
            error_fn(wxString::FromUTF8(uploadResponse.get<std::string>("message")));
        }
    } catch (const std::exception &) { 
        res = false;
        error_fn(_L("Error during file upload"));
    }
    // set printer type for uploaded gcode
    if (res) {
        pt::ptree update_file_response;
        update_file(update_file_response, file_id, printer_type_id, "OrcaSlicer");
        try {
            if (!update_file_response.get<bool>("result")) {
                const std::string msg = update_file_response.get<std::string>("message", "Unknown update error");
                BOOST_LOG_TRIVIAL(warning) << "Failed to update uploaded file: " << msg;
            }
        } catch (const std::exception& ex) {
            BOOST_LOG_TRIVIAL(warning) << "Could not parse update response: " << ex.what();
        }
        if (upload_data.post_action == PrintHostPostUploadAction::StartPrint && !upload_data.use_3mf) {
            auto quick_print_url = make_url("quickprint?file_id=" + file_id);
            wxLaunchDefaultBrowser(quick_print_url);
        }
    }
 
    return res;
}

References _L, _u8L, check_session(), Slic3r::PrintHost::format_error(), get_cloud_printer_types(), get_cloud_projects_list(), get_name(), Slic3r::http, m_apikey, m_cafile, m_preset_name, make_url(), Slic3r::Http::post(), Slic3r::PrintHostUpload::post_action, Slic3r::PrintHostUpload::source_path, Slic3r::StartPrint, update_file(), Slic3r::PrintHostUpload::upload_path, and Slic3r::PrintHostUpload::use_3mf.

Here is the call graph for this function:

validate_version_text()

bool Slic3r::C3DPrinterOS::validate_version_text ( const boost::optional< std::string > & version_text ) const

protected

{
    return version_text ? boost::starts_with(*version_text, "3DPrinterOS") : true;
}

Member Data Documentation

m_api_session_file_path

std::string Slic3r::C3DPrinterOS::m_api_session_file_path

private

Referenced by C3DPrinterOS(), load_api_session(), log_out(), and save_api_session().

m_apikey

std::string Slic3r::C3DPrinterOS::m_apikey

private

Referenced by C3DPrinterOS(), check_session(), get_cloud_printer_types(), get_cloud_projects_list(), is_logged_in(), load_api_session(), update_file(), and upload().

m_cafile

std::string Slic3r::C3DPrinterOS::m_cafile

private

Referenced by login_with_token(), send_form(), and upload().

m_host

std::string Slic3r::C3DPrinterOS::m_host

private

Referenced by C3DPrinterOS(), get_host(), and make_url().

m_host_type

std::string Slic3r::C3DPrinterOS::m_host_type

private

m_preset_name

std::string Slic3r::C3DPrinterOS::m_preset_name

private

Referenced by C3DPrinterOS(), and upload().

m_username

std::string Slic3r::C3DPrinterOS::m_username

private

Referenced by get_test_ok_msg(), and load_api_session().

---

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

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