get_current_account

get_current_account() returns the current account authorization context as the public blaze::account result object.

Function variants

blaze::account get_current_account();
blaze::account get_current_account(std::error_code& ec) noexcept;
void async_get_current_account(std::function<void(std::error_code, blaze::account)> callback);
blaze::coro::awaitable_result<blaze::account> co_get_current_account();

Status vs error

account.status is the API result. std::error_code and std::system_error are used for transport/runtime failures only.

Result

struct account {
  std::string login;
  std::vector<std::string> levels;
  std::string comment;
  std::string ip_address;
  std::chrono::seconds time_left{};
  bool license_required{};
  blaze::status status{};

  bool good() const noexcept;
  bool already_authorized() const noexcept;
};

Prop

Type

account.good() is equivalent to status == blaze::status::ok.

Checking returned fields

Missing fields are returned as default values. If account.status != blaze::status::ok, treat metadata fields as optional in practice and check them explicitly.

Field	Practical check
`account.login`	`account.login.empty()`
`account.levels`	`account.levels.empty()`
`account.comment`	`account.comment.empty()`
`account.ip_address`	`account.ip_address.empty()`
`account.time_left`	`account.time_left.count() == 0`
`account.license_required`	Use `account.status == blaze::status::ok` before relying on it. `false` alone is not a reliable "missing field" check.

Behavior notes

Call get_current_account only after successful connect and initialize.
This method reads the current in-session account context. It does not perform a new authorization request.
It works only for credential-based authorization context. If the session is not authorized by credentials, the operation returns blaze::status::not_authorized.
If the server omits levels, comment, ip_address, time_left, or license_required, the library returns default values.
If the current account no longer has active license coverage, the operation returns blaze::status::app_user_has_no_valid_licenses.
On blaze::status::app_user_has_no_valid_licenses, some metadata such as login, levels, comment, ip_address, and license_required can still be useful, while time_left remains 0s.

Example

Compilation note

Synchronous and Asynchronous examples compile in the same form from C++17 to C++26.

#include "blazeauth/api/api.hpp"

#include <iostream>
#include <string>
#include <system_error>

void print_error_code(const std::string& context, const std::error_code& ec) {
  std::cout << context << ": " << ec.message() << " ("
            << ec.value() << " : " << ec.category().name() << ")\n";
}

std::string read_line(const std::string& label) {
  std::string value;
  std::cout << label << ": ";
  std::getline(std::cin, value);
  return value;
}

void print_status(const std::string& context, blaze::status status) {
  std::cout << context << ": "
            << static_cast<unsigned int>(status)
            << " (" << blaze::to_string(status) << ")\n";
}

int main() {
  const std::string websocket_api_key = read_line("Websocket API key");
  const std::string client_id = read_line("Client ID");
  const std::string login = read_line("Login");
  const std::string password = read_line("Password");

  blaze::session session;

  try {
    const blaze::api_server server = session.connect();
    std::cout << "Connected to server location: " << server.location << '\n';

    const blaze::application app = session.initialize(websocket_api_key, client_id);
    if (!app.good()) {
      print_status("Initialize returned status", app.status);
      return 1;
    }

    blaze::account_credentials credentials;
    credentials.login = login;
    credentials.password = password;
    credentials.type = blaze::credentials_type::login_password;

    const blaze::account auth_result = session.authorize(credentials);
    if (!auth_result.good()) {
      print_status("Authorize returned status", auth_result.status);
      return 1;
    }

    const blaze::account current_account = session.get_current_account();
    if (!current_account.good()) {
      print_status("Get-current-account returned status", current_account.status);
      return 1;
    }

    std::cout << "Current account login: " << current_account.login << '\n';
    std::cout << "Levels count: " << current_account.levels.size() << '\n';
    std::cout << "Time left: " << current_account.time_left.count() << "s\n";
    std::cout << "License required: " << (current_account.license_required ? "true" : "false") << '\n';

    session.shutdown();
  } catch (const std::system_error& e) {
    print_error_code("Get-current-account failed", e.code());
    return 1;
  }

  return 0;
}