AbstractAuthzApiRequest.h

#ifndef TENDUKE_EE_LICENSING_AUTZHAPI_ABSTRACTAUTHZAPIREQUEST_H
#define TENDUKE_EE_LICENSING_AUTZHAPI_ABSTRACTAUTHZAPIREQUEST_H
 
#include "../LicensingRequest.h"
#include "http/HTTPClient.h"
#include "http/HTTPRequestAuthenticator.h"
#include "http/HTTPResponseToException.h"
#include "log/log.h"
 
#include <memory>
#include <string>
 
 
namespace tenduke { namespace ee { namespace licensing { namespace authzapi {
 

template<class T>
class AbstractAuthzApiRequest : public ::tenduke::ee::licensing::authzapi::LicensingRequest<T>
{
public:
    virtual ~AbstractAuthzApiRequest() = default;

    AbstractAuthzApiRequest(
            const std::shared_ptr<const ::tenduke::http::HTTPClient> &httpClient,
            const std::shared_ptr<const ::tenduke::http::HTTPRequestAuthenticator> &httpRequestAuthenticator,
            const std::shared_ptr<const ::tenduke::http::HTTPResponseToException> &throwException,
            const std::shared_ptr<::tenduke::log::Logger> &logger
    ) : http(httpClient)
      , httpRequestAuthenticator(httpRequestAuthenticator)
      , throwException(throwException)
      , log(logger)
    {}
 
public:
    T execute() override
    {
        // Build the HTTP-request
        auto request = http->request();
        auto urlBuilder = request.url();
        buildRequestUrl(urlBuilder);
        std::string url = urlBuilder.buildString();
 
        if (this->log->isDebugEnabled()) {
            this->log->debug("AbstractAuthzApiRequest::execute() Executing HTTP request with URL " + url + " ...");
        }
 
        // Build and execute the request:
        auto httpCall = request.get()
                .authenticateWith(httpRequestAuthenticator)
                .url(url)
                .call();
        auto httpResponse = httpCall->execute();
 
        if (! httpResponse->isSuccessful()) {
            this->log->warning("AbstractAuthzApiRequest::execute() ...HTTP request failed with status code " + std::to_string(httpResponse->getStatusCode()));
            throwException->basedOn(*httpResponse);
        }
 
        this->log->debug("AbstractAuthzApiRequest::execute() ...HTTP request successfully executed");
 
        return parseResponsePayload(httpResponse->getPayloadAsString());
    }
 
protected:
    virtual T parseResponsePayload(const std::string &payload) const = 0;

    virtual void buildRequestUrl(::tenduke::net::URLBuilder &url) const = 0;
 
private:
    const std::shared_ptr<::tenduke::log::Logger> log;
    const std::shared_ptr<const ::tenduke::http::HTTPClient> http;
    const std::shared_ptr<const ::tenduke::http::HTTPRequestAuthenticator> httpRequestAuthenticator;
    const std::shared_ptr<const ::tenduke::http::HTTPResponseToException> throwException;
};
 
 
}}}}
 
#endif // TENDUKE_EE_LICENSING_AUTZHAPI_ABSTRACTAUTHZAPIREQUEST_H