AbstractAPIRequestMixin.h

#ifndef TENDUKE_SE_LICENSING_REST_ABSTRACTAPIREQUEST_H
#define TENDUKE_SE_LICENSING_REST_ABSTRACTAPIREQUEST_H
 
#include "./APIRequest.h"
#include "../config/BackendConfiguration.h"
#include "http/HTTPClient.h"
#include "http/HTTPRequestAuthenticator.h"
#include "http/HTTPResponseToException.h"
#include "json/JSONParser.h"
 
#include <memory>
#include <utility>
 
 
namespace tenduke { namespace se { namespace licensing { namespace rest {
 
template<class T>
class AbstractAPIRequestMixin
{
public:
    AbstractAPIRequestMixin(
            std::string baseUrl
          , 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<const ::tenduke::json::JSONParser> &jsonParser
    ) : baseUrl(std::move(baseUrl))
      , http(httpClient)
      , httpRequestAuthenticator(httpRequestAuthenticator)
      , throwException(throwException)
      , parseJSON(jsonParser)
    {}
 
    virtual ~AbstractAPIRequestMixin() = default;
 
protected:
    virtual T executeRequest()
    {
        ::tenduke::http::HTTPRequestBuilder request = http->request();
        ::tenduke::net::URLBuilder urlBuilder = request.url();
        buildUrl(urlBuilder);
        request.url(urlBuilder.buildString());
        setHeaders(request);
 
        if (httpRequestAuthenticator != nullptr) {
            request.authenticateWith(httpRequestAuthenticator);
        }
 
        auto response = http->call(request.build())->execute();
 
        if (! response->isSuccessful()) {
            throwException->basedOn(*response);
        }
 
        return fromJSON(response->getPayloadAsString());
    }
 
protected:
    virtual T fromJSON(const std::string &responseBody) const = 0;
 
    virtual void buildUrl(::tenduke::net::URLBuilder &urlBuilder)
    const
    {
        urlBuilder.baseURL(baseUrl);
    }
 
    virtual ::tenduke::http::HTTPRequestBuilder & setHeaders(::tenduke::http::HTTPRequestBuilder &request)
    const
    {
        return request;
    }
 
protected:
    const std::string baseUrl;
 
    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;
 
    const std::shared_ptr<const ::tenduke::json::JSONParser> parseJSON;
};
 
}}}}
 
#endif //TENDUKE_SE_LICENSING_REST_ABSTRACTAPIREQUEST_H