FluentLicenseCheckoutBuilder.h

#ifndef TENDUKE_EE_LICENSING_FLUENTCHECKOUTBUILDER_H
#define TENDUKE_EE_LICENSING_FLUENTCHECKOUTBUILDER_H
 
#include "../../config/ClientProperties.h"
#include "./LicenseCheckoutParameters.h"
 
#include <string>
#include <utility>
#include <vector>
 
namespace tenduke { namespace ee { namespace licensing {
 
template<typename BUILDER>
class FluentLicenseCheckoutBuilder
{
public:
    explicit FluentLicenseCheckoutBuilder(::tenduke::ee::ClientProperties clientProperties)
    : clientProperties(std::move(clientProperties))
    , consumeCount(tenduke::ee::licensing::LicenseCheckoutParameters::DEFAULT_CONSUME_COUNT)
    , consumeDuration(tenduke::ee::licensing::LicenseCheckoutParameters::DEFAULT_CONSUME_DURATION)
    , consumptionMode(tenduke::ee::licensing::LicenseCheckoutParameters::ConsumptionMode::DEFAULT)
    , entitlementId("")
    , organizationId("")
    {}
 
    BUILDER & seat(
            const std::string &productName,
            const std::string &requestedVersion = "",
            const std::string &licenseId = ""
    ) {
        return item(productName, requestedVersion, licenseId);
    }
 
    BUILDER & item(
            const std::string &itemName,
            const std::string &requestedVersion = "",
            const std::string &licenseId = ""
    ) {
        items.emplace_back(itemName, requestedVersion, licenseId);
        return static_cast<BUILDER&>(*this);
    }
 
    BUILDER & count(std::uint64_t pConsumeCount)
    {
        this->consumeCount = pConsumeCount;
        return static_cast<BUILDER&>(*this);
    }
 
 
    BUILDER & duration(std::uint64_t pConsumeDuration)
    {
        this->consumeDuration = pConsumeDuration;
        return static_cast<BUILDER&>(*this);
    }
 
 
    BUILDER & fromEntitlement(const std::string &pEntitlementId)
    {
        this->entitlementId = pEntitlementId;
        return static_cast<BUILDER&>(*this);
    }
 
 
    BUILDER & fromOrganization(const std::string &pOrganizationId)
    {
        this->organizationId = pOrganizationId;
        return static_cast<BUILDER&>(*this);
    }
 
 
    BUILDER & mode(enum tenduke::ee::licensing::LicenseCheckoutParameters::ConsumptionMode pConsumptionMode)
    {
        this->consumptionMode = pConsumptionMode;
        return static_cast<BUILDER&>(*this);
    }
 
 
    BUILDER & version(const std::string &pGlobalVersion)
    {
        this->globalVersion = pGlobalVersion;
        return static_cast<BUILDER&>(*this);
    }
 
 
protected:
    virtual tenduke::ee::licensing::LicenseCheckoutParameters buildParameters()
    {
        return LicenseCheckoutParameters(
                items,
                consumptionMode,
                globalVersion,
                clientProperties,
                consumeDuration,
                consumeCount,
                entitlementId,
                organizationId
        );
    }
 
private:
    ::tenduke::ee::ClientProperties clientProperties;
    std::uint64_t consumeCount;
    std::uint64_t consumeDuration;
    enum tenduke::ee::licensing::LicenseCheckoutParameters::ConsumptionMode consumptionMode;
    std::string entitlementId;
    std::string globalVersion;
    std::string organizationId;
    std::vector<tenduke::ee::licensing::LicenseCheckoutItem> items;
};
 
}}}
 
#endif //TENDUKE_EE_LICENSING_FLUENTCHECKOUTBUILDER_H