Slic3r::GUI::OAuthJob Class Reference

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

Inheritance diagram for Slic3r::GUI::OAuthJob:

Collaboration diagram for Slic3r::GUI::OAuthJob:

Public Types
enum	JobPrepareState { PREPARE_STATE_DEFAULT = 0 , PREPARE_STATE_MENU = 1 }

Public Member Functions
	OAuthJob (const OAuthData &input)
void	process (Ctl &ctl) override
void	finalize (bool canceled, std::exception_ptr &e) override
void	set_event_handle (wxWindow *hanle)

Static Public Member Functions
static void	parse_token_response (const std::string &body, bool error, OAuthResult &result)

Private Attributes
HttpServer	local_authorization_server
OAuthData	_data
wxWindow *	m_event_handle {nullptr}

Detailed Description

Member Enumeration Documentation

JobPrepareState

enum Slic3r::GUI::Job::JobPrepareState

inherited

Enumerator
PREPARE_STATE_DEFAULT
PREPARE_STATE_MENU

                         {
        PREPARE_STATE_DEFAULT = 0,
        PREPARE_STATE_MENU = 1,
    };

Constructor & Destructor Documentation

OAuthJob()

Slic3r::GUI::OAuthJob::OAuthJob ( const OAuthData & input )

explicit

: local_authorization_server(input.params.callback_port), _data(input) {}

References _data, and local_authorization_server.

Member Function Documentation

finalize()

void Slic3r::GUI::OAuthJob::finalize ( bool canceled, std::exception_ptr & e )

overridevirtual

Reimplemented from Slic3r::GUI::Job.

{
    // Make sure it's stopped
    local_authorization_server.stop();
 
    wxCommandEvent event(EVT_OAUTH_COMPLETE_MESSAGE);
    event.SetEventObject(m_event_handle);
    wxPostEvent(m_event_handle, event);
}

References local_authorization_server, and m_event_handle.

parse_token_response()

void Slic3r::GUI::OAuthJob::parse_token_response ( const std::string & body, bool error, OAuthResult & result )

static

{
    const auto j = nlohmann::json::parse(body, nullptr, false, true);
    if (j.is_discarded()) {
        BOOST_LOG_TRIVIAL(warning) << "Invalid or no JSON data on token response: " << body;
        result.error_message = _u8L("Unknown error");
    } else if (error) {
        if (j.contains("error_description")) {
            j.at("error_description").get_to(result.error_message);
        } else {
            result.error_message = _u8L("Unknown error");
        }
    } else {
        j.at("access_token").get_to(result.access_token);
        j.at("refresh_token").get_to(result.refresh_token);
        result.success = true;
    }
}

References _u8L, Slic3r::GUI::OAuthResult::access_token, Slic3r::GUI::OAuthResult::error_message, Slic3r::GUI::OAuthResult::refresh_token, and Slic3r::GUI::OAuthResult::success.

Referenced by Slic3r::SimplyPrint::do_api_call(), and process().

Here is the caller graph for this function:

process()

void Slic3r::GUI::OAuthJob::process ( Ctl & ctl )

overridevirtual

Implements Slic3r::GUI::Job.

{
    // Prepare auth process
    std::shared_ptr<ThreadSafeQueueSPSC<OAuthResult>> queue = std::make_shared<ThreadSafeQueueSPSC<OAuthResult>>();
 
    // Setup auth server to receive OAuth code from callback url
    local_authorization_server.set_request_handler([this, queue](const std::string& url) -> std::shared_ptr<HttpServer::Response> {
        if (boost::contains(url, "/callback")) {
            const auto code = url_get_param(url, "code");
            const auto state = url_get_param(url, "state");
 
            const auto handle_auth_fail = [this, queue](const std::string& message) -> std::shared_ptr<HttpServer::ResponseRedirect> {
                queue->push(OAuthResult{false, message});
                return std::make_shared<HttpServer::ResponseRedirect>(this->_data.params.auth_fail_redirect_url);
            };
 
            if (state != _data.params.state) {
                BOOST_LOG_TRIVIAL(warning) << "The provided state was not correct. Got " << state << " and expected " << _data.params.state;
                return handle_auth_fail(_u8L("The provided state is not correct."));
            }
 
            if (code.empty()) {
                const auto error_code = url_get_param(url, "error_code");
                if (error_code == "user_denied") {
                    BOOST_LOG_TRIVIAL(debug) << "User did not give the required permission when authorizing this application";
                    return handle_auth_fail(_u8L("Please give the required permissions when authorizing this application."));
                }
 
                BOOST_LOG_TRIVIAL(warning) << "Unexpected error when logging in. Error_code: " << error_code << ", State: " << state;
                return handle_auth_fail(_u8L("Something unexpected happened when trying to log in, please try again."));
            }
 
 
            OAuthResult r;
            // Request the access token from the authorization server.
            auto http = Http::post(_data.params.token_url);
            http.timeout_connect(5)
                .timeout_max(5)
                .form_add("client_id", _data.params.client_id)
                .form_add("redirect_uri", _data.params.callback_url)
                .form_add("grant_type", "authorization_code")
                .form_add("code", code)
                .form_add("code_verifier", _data.params.verification_code)
                .form_add("scope", _data.params.scope)
                .on_complete([&](std::string body, unsigned status) { parse_token_response(body, false, r); })
                .on_error([&](std::string body, std::string error, unsigned status) { parse_token_response(body, true, r); })
                .perform_sync();
 
            queue->push(r);
            return std::make_shared<HttpServer::ResponseRedirect>(r.success ? _data.params.auth_success_redirect_url :
                                                                              _data.params.auth_fail_redirect_url);
        } else {
            queue->push(OAuthResult{false});
            return std::make_shared<HttpServer::ResponseNotFound>();
        }
    });
 
    // Run the local server
    local_authorization_server.start();
 
    // Wait until we received the result
    bool received = false;
    while (!ctl.was_canceled() && !received ) {
        queue->consume_one(BlockingWait{1000}, [this, &received](const OAuthResult& result) {
            *_data.result = result;
            received      = true;
        });
    }
 
    // Handle timeout
    if (!received && ctl.was_canceled()) {
        _data.result->error_message = _u8L("User canceled.");
    } else {
        // Wait a while to ensure the response has sent
        std::this_thread::sleep_for(std::chrono::milliseconds(1500));
    }
}

References _data, _u8L, Slic3r::http, local_authorization_server, parse_token_response(), Slic3r::Http::post(), Slic3r::GUI::OAuthResult::success, Slic3r::GUI::url_get_param(), and Slic3r::GUI::Job::Ctl::was_canceled().

Here is the call graph for this function:

set_event_handle()

void Slic3r::GUI::OAuthJob::set_event_handle ( wxWindow * hanle )

inline

{ m_event_handle = hanle; }

References m_event_handle.

Member Data Documentation

_data

OAuthData Slic3r::GUI::OAuthJob::_data

private

Referenced by OAuthJob(), and process().

local_authorization_server

HttpServer Slic3r::GUI::OAuthJob::local_authorization_server

private

Referenced by OAuthJob(), finalize(), and process().

m_event_handle

wxWindow* Slic3r::GUI::OAuthJob::m_event_handle {nullptr}

private

{nullptr};

Referenced by finalize(), and set_event_handle().

---

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

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