10Duke Enterprise C++ Client: client/enterprise/examples/demo

Searching...
No Matches
#ifndef TENDUKE_EXAMPLES_UTILS_H
#define TENDUKE_EXAMPLES_UTILS_H
 
#include "licensing/checkout/LicenseCheckoutResponse.h"
#include "licensing/release/LicenseReleaseResponse.h"
#include "licensing/renew/LicenseRenewResponse.h"
#include "oidc/OIDCState.h"
 
#include <cstdlib>
#include <iostream>
#include <memory>
#include <string>
 
namespace tenduke {namespace eg {
 
    const std::string DEMO_DEPLOYMENT_URL = "https://your-deployment-url-here";
 
    const std::string HTTP_MESSAGE_WHEN_LOGIN_SUCCEEDS =
            "HTTP/1.1 200 OK\n"
            "Content-Type: text/html; charset=utf-8\n"
            "\n"
            "<html>\n"
            "<head>\n"
            "  <title>Login successful, you can close the tab</title>\n"
            "  <style>\n"
            "    body {\n"
            "      display: flex; flex-direction: column; justify-content: center;\n"
            "      min-height: 100vh;\n"
            "    }\n"
            "    .center {\n"
            "      text-align: center;\ns"
            "    }\n"
            "  </style>\n"
            "</head>\n"
            "<body>\n"
            "  <div class=\"center\">\n"
            "    <H1>Login successful</H1>\n"
            "    <p>You can close this tab now</p>\n"
            "  </div>\n"
            "</body>\n"
            "</html>"
    ;
    tenduke::oidc::OIDCState * mutate(const std::shared_ptr<const tenduke::oidc::OIDCState> &state)
    {
        return (tenduke::oidc::OIDCState*)((void*)state.get());
    }
 
    std::string getDeploymentURL(int argc, char **argv)
    {
        auto fromEnvironment = std::getenv("XD_DEPLOYMENT_URL");
        if (fromEnvironment == NULL) {
            return ::tenduke::eg::DEMO_DEPLOYMENT_URL;
        }
        return fromEnvironment;
    }
 
    void setExpiresAt(
            const std::shared_ptr<const tenduke::oidc::OIDCState> &state,
            std::int64_t expiresAt
    ) {
        mutate(state)->setExpiresAt(expiresAt);
    }
 
    void setRefreshToken(
            const std::shared_ptr<const tenduke::oidc::OIDCState> &state,
            const std::string& refreshToken
    ) {
        mutate(state)->setRefreshToken(refreshToken);
    }
 
    void dumpToConsole(const ::tenduke::ee::licensing::Lease &lease)
    {
        std::cout << " * "
                  << lease.name
                  << ": id=" << lease.licenseId
                  << ", leaseId = " << lease.leaseId
                  << ", expires = " << lease.leaseExpiresEpochS
                  << (lease.consumedVersion.empty() ? "" : " , version = " + lease.consumedVersion)
                  << ", licenseId = " << lease.licenseId
                  << std::endl;
    }
 
    void dumpToConsole(const std::vector<tenduke::ee::licensing::Lease> &leases)
    {
        for (auto const &lease : leases) {
            dumpToConsole(lease);
        }
    }
 
    void dumpToConsole(const std::map<std::string, tenduke::ee::licensing::Lease> &leases)
    {
        std::vector<tenduke::ee::licensing::Lease> list;
        list.reserve(leases.size());
        for (auto const &lease : leases) {
            list.push_back(lease.second);
        }
        dumpToConsole(list);
    }
 
    void dumpToConsole(const tenduke::ee::licensing::LicenseCheckoutResponse &response)
    {
        if (response.leases.empty()) {
            std::cout << "No items successfully checked out" << std::endl;
        }
        else {
            std::cout << "Successfully checked out items:" << std::endl;
 
            dumpToConsole(response.leases);
        }
        if (response.hasErrors()) {
            std::cout << "Failed items:" << std::endl;
            for (auto const &failedItem: response.errors) {
                std::cout << " - " << failedItem.first << ":" << std::endl;
                std::cout << "   error code: " << failedItem.second.getErrorCode() << std::endl;
                std::cout << "   error key: " << failedItem.second.getErrorKey() << std::endl;
                std::cout << "   error message: " << failedItem.second.getErrorMessage() << std::endl;
                std::cout << "   technical: " << failedItem.second.getErrorTechnical() << std::endl;
            }
        }
    }
 
    void dumpToConsole(const tenduke::ee::licensing::LicenseRenewResponse &response)
    {
        if (response.leases.empty()) {
            std::cout << "No leases successfully renewed" << std::endl;
        }
        else {
            std::cout << "Successfully renewed leases:" << std::endl;
 
            dumpToConsole(response.leases);
        }
        if (response.hasErrors()) {
            std::cout << "Failed items:" << std::endl;
            for (auto const &failedItem: response.errors) {
                std::cout << " - " << failedItem.first << ":" << std::endl;
                std::cout << "   error code: " << failedItem.second.getErrorCode() << std::endl;
                std::cout << "   error key: " << failedItem.second.getErrorKey() << std::endl;
                std::cout << "   error message: " << failedItem.second.getErrorMessage() << std::endl;
                std::cout << "   technical: " << failedItem.second.getErrorTechnical() << std::endl;
            }
        }
    }
 
 
    void dumpToConsole(const tenduke::ee::licensing::LicenseReleaseResponse &response)
    {
        if (response.leaseIds.empty()) {
            std::cout << "No leases successfully released" << std::endl;
        }
        else {
            std::cout << "Successfully released leases:" << std::endl;
 
            for (auto const &leaseId: response.leaseIds) {
                std::cout << " * " << leaseId << std::endl;
            }
        }
        if (response.hasErrors()) {
            std::cout << "Failed leases:" << std::endl;
            for (auto const &failedItem: response.errors) {
                std::cout << " - " << failedItem.first << ":" << std::endl;
                std::cout << "   error code: " << failedItem.second.getErrorCode() << std::endl;
                std::cout << "   error key: " << failedItem.second.getErrorKey() << std::endl;
                std::cout << "   error message: " << failedItem.second.getErrorMessage() << std::endl;
                std::cout << "   technical: " << failedItem.second.getErrorTechnical() << std::endl;
            }
        }
    }
 
    void dumpToConsole(const tenduke::oidc::OIDCState &state)
    {
        std::cout << "OIDC-state:" << std::endl;
        //std::cout << " - id-token: " << state.getIdToken().getSerialized() << std::endl;
        std::cout << " - ID-token: " << std::endl;
        std::cout << "   - subject: " << state.getIdToken().getSubject() << std::endl;
        std::cout << "   - issuer: " << state.getIdToken().getIssuer() << std::endl;
        std::cout << " - access token: " << state.getAccessToken() << std::endl;
        if (state.isRefreshable()) {
            std::cout << " - refresh token: " <<state.getRefreshToken() << std::endl;
        }
        else {
            std::cout << " - not refreshable" << std::endl;
        }
        std::cout << " - expires: " << state.getExpiresAt() << std::endl;
    }
 
    void dumpToConsole(const std::shared_ptr<const tenduke::oidc::OIDCState> &state)
    {
        if (state == nullptr) {
            std::cout << "No OIDC state" << std::endl;
            return;
        }
        dumpToConsole(*state);
    }
}}
 
namespace demo = tenduke::eg;
 
#endif