AbstractLicenseTokenAuthzApiRequest.h

#ifndef TENDUKE_EE_LICENSING_AUTZHAPI_ABSTRACTLICENSETOKENAUTHZAPIREQUEST_H
#define TENDUKE_EE_LICENSING_AUTZHAPI_ABSTRACTLICENSETOKENAUTHZAPIREQUEST_H
 
#include "./AbstractAuthzApiRequest.h"
#include "../../LicenseTokenParser.h"
 
#include "http/HTTPClient.h"
#include "http/HTTPRequestAuthenticator.h"
#include "http/HTTPResponseToException.h"
 
#include <memory>
#include <string>
 
 
namespace tenduke { namespace ee { namespace licensing { namespace authzapi {
 
 
template<class T>
class AbstractLicenseTokenAuthzApiRequest : public ::tenduke::ee::licensing::authzapi::AbstractAuthzApiRequest<T>
{
public:
    virtual ~AbstractLicenseTokenAuthzApiRequest() = default;
 
    AbstractLicenseTokenAuthzApiRequest(
            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::ee::licensing::impl::LicenseTokenParser> &licenseTokenParser
    ) : ::tenduke::ee::licensing::authzapi::AbstractAuthzApiRequest<T>(httpClient, httpRequestAuthenticator, throwException)
      , parseLicenseToken(licenseTokenParser)
    {}
 
protected:
    T parseResponsePayload(const std::string &payload) const override
    {
        std::map<std::string, ::tenduke::ee::licensing::Lease> items;
        std::map<std::string, ::tenduke::ee::licensing::LicensingError> failedItems;
        int startOfToken = 0;
 
        // If the response contains multiple licensed items, each of them are
        // encoded separately as JWT and the JWTs are concatenated together. This parses those out.
        std::size_t payloadLength = payload.length();
        for (int i = 0; i < payloadLength; i++) {
            if (payload.at(i) == '&') {
                handleParsedResult(
                        parseLicenseToken->from(payload.substr(startOfToken, i - startOfToken)),
                        items,
                        failedItems
                );
 
                startOfToken = i + 1;
            }
        }
        // Handle last token:
        if (startOfToken < payloadLength) {
            handleParsedResult(
                    parseLicenseToken->from(payload.substr(startOfToken)),
                    items,
                    failedItems
            );
        }
        return {items, failedItems};
    }
 
private:
    void handleParsedResult(
            const ::tenduke::ee::licensing::impl::LeaseOrError &leaseOrError,
            std::map<std::string, ::tenduke::ee::licensing::Lease> &items,
            std::map<std::string, ::tenduke::ee::licensing::LicensingError> &failedItems
    ) const
    {
        if (leaseOrError.isLease()) {
            items.emplace(leaseOrError.lease.name, leaseOrError.lease);
        }
        else {
            failedItems.emplace(leaseOrError.error.getItemName(), leaseOrError.error);
        }
    }
 
private:
    const std::shared_ptr<const ::tenduke::ee::licensing::impl::LicenseTokenParser> parseLicenseToken;
};
 
 
}}}}
 
#endif // TENDUKE_EE_LICENSING_AUTZHAPI_ABSTRACTLICENSETOKENAUTHZAPIREQUEST_H