AbstractClientFactory.h

#ifndef TENDUKE_EE_BASECLIENTFACTORY_H
#define TENDUKE_EE_BASECLIENTFACTORY_H
 
#include "./createTendukeClient.h"
#include "./TendukeClient.h"
#include "./config/ClientProperties.h"
#include "./state/DeserializeStateFromJSON.h"
#include "createDefaultTendukeServices.h"
#include "ServiceConfiguration.h"
#include "TendukeServices.h"
#include "log/log.h"
#include "oidc/session/OIDCLogin.h"
 
#include <memory>
#include <string>
 
namespace tenduke { namespace ee {
 
template<class P>
class AbstractClientFactory
{
public:
    virtual ~AbstractClientFactory() = default;
 
    AbstractClientFactory(
            const std::string &clientId,
            const ::tenduke::ServiceConfiguration &serviceConfiguration = ::tenduke::ServiceConfiguration()
    )
    : services(::tenduke::createDefaultTendukeServices(clientId, serviceConfiguration))
    {}
 
    explicit AbstractClientFactory(const ::tenduke::TendukeServices &services) : services(services) {}
 
public:
    virtual std::unique_ptr<::tenduke::ee::TendukeClient> createClient(
            const ::tenduke::ee::ClientProperties &clientProperties,
            const std::string &serviceUrl,
            const ::tenduke::oauth::OAuthBackendConfiguration &oauthBackendConfiguration,
            const ::tenduke::oidc::OIDCConfiguration &oidcConfiguration,
            const P &authenticationConfiguration,
            const std::string &initialStateAsJSON = {}
    ) const
    {
        auto oauthConfiguration = mkOAuthConfiguration(oauthBackendConfiguration, authenticationConfiguration);
        auto oidcConfig = std::shared_ptr<::tenduke::oidc::OIDCConfiguration>(new ::tenduke::oidc::OIDCConfiguration(oidcConfiguration));
 
        return ::tenduke::ee::createClient(
                services,
                mkLicensingConfiguration(serviceUrl, clientProperties, oidcConfiguration),
                oauthConfiguration,
                oidcConfig,
                createOIDCLoginService(oauthConfiguration, oidcConfig, authenticationConfiguration),
                authenticationConfiguration.oidcSessionConfiguration,
                ::tenduke::ee::DeserializeStateFromJSON(services.jwtParser,services.jsonParser).from(initialStateAsJSON)
        );
    }
 
    std::unique_ptr<::tenduke::ee::TendukeClient> createClientUsingAutodiscovery(
            const ::tenduke::ee::ClientProperties &clientProperties,
            const std::string &serviceUrl,
            const P &authenticationConfiguration,
            const std::string &initialStateAsJSON = {}
    ) const
    {
        // Perform OIDC auto discovery
        auto discoveryResult = services.oidcBackendConfiguration->discover(serviceUrl + "/.well-known/openid-configuration");
        auto oidcConfiguration = services.oidcBackendConfiguration->toOIDCConfiguration(discoveryResult);
        auto oauthConfiguration = mkOAuthConfiguration(*discoveryResult.getOAuthConfiguration(), authenticationConfiguration);
 
        dumpAutodiscoveryResult(*services.oidcBackendConfiguration, discoveryResult);
 
        return ::tenduke::ee::createClient(
                services,
                mkLicensingConfiguration(serviceUrl, clientProperties, *oidcConfiguration),
                oauthConfiguration,
                oidcConfiguration,
                createOIDCLoginService(oauthConfiguration, oidcConfiguration, authenticationConfiguration),
                authenticationConfiguration.oidcSessionConfiguration,
                ::tenduke::ee::DeserializeStateFromJSON(services.jwtParser,services.jsonParser).from(initialStateAsJSON)
        );
    }
 
protected:
    virtual std::shared_ptr<::tenduke::oidc::OIDCLogin> createOIDCLoginService(
            const std::shared_ptr<const ::tenduke::oauth::OAuthConfiguration> &oauthConfig,
            const std::shared_ptr<const ::tenduke::oidc::OIDCConfiguration> &oidcConfig,
            const P &authenticationConfig
    ) const = 0;
 
    virtual std::shared_ptr<::tenduke::oauth::OAuthConfiguration> mkOAuthConfiguration(
            const ::tenduke::oauth::OAuthBackendConfiguration &oauthBackendConfig,
            const P &authenticationConfig
    ) const = 0;
 
    virtual std::shared_ptr<::tenduke::ee::licensing::LicensingConfiguration> mkLicensingConfiguration(
            const std::string &serviceUrl,
            const ::tenduke::ee::ClientProperties &clientProperties,
            const ::tenduke::oidc::OIDCConfiguration &oidcConfig
    ) const
    {
        return std::make_shared<::tenduke::ee::licensing::LicensingConfiguration>(
                serviceUrl + "/authz/",
                clientProperties,
                oidcConfig.verificationKey,
                oidcConfig.digestAlgorithm
        );
    }
 
    virtual void dumpAutodiscoveryResult(
            const ::tenduke::oidc::AutoDiscovery &service,
            const ::tenduke::oidc::AutoDiscoveryResult &result
    ) const
    {
        ::tenduke::log::debug("Auto discovered properties:");
        ::tenduke::log::debug(" - authorization endpoint: " + result.getOAuthConfiguration()->authorizationEndpointUrl);
        ::tenduke::log::debug(" - token endpoint:         " + result.getOAuthConfiguration()->tokenEndpointUrl);
        ::tenduke::log::debug(" - userinfo endpoint:      " + result.getOOIDCConfiguration()->userinfoEndpoint);
        ::tenduke::log::debug(" - issuer:                 " + result.getOOIDCConfiguration()->issuer);
        ::tenduke::log::debug(" - verification key:");
 
        auto jwk = service.getDefaultVerificationKey(result);
 
        ::tenduke::log::debug(jwk->key->toPEM());
    }
 
protected:
    ::tenduke::TendukeServices services;
};
 
 
}}
 
 
#endif //TENDUKE_EE_BASECLIENTFACTORY_H