FluentConsumptionBuilder.h

#ifndef TENDUKE_SE_LICENSING_FLUENTCONSUMPTIONBUILDER_H
#define TENDUKE_SE_LICENSING_FLUENTCONSUMPTIONBUILDER_H
 
#include "./LicenseCheckoutArguments.h"
#include "./LicenseCheckoutParameters.h"
#include "../../License.h"
 
#include <cstdint>
#include <string>
#include <utility>
 
namespace tenduke { namespace se { namespace licensing {

template <typename Builder>
class FluentConsumptionBuilder
{
public:
    explicit FluentConsumptionBuilder(std::string licenseKey)
    : buildingItem(false)
    , licenseKey(std::move(licenseKey))
    , qty(0)
    , qtyDimension(::tenduke::se::licensing::License::QuantityDimension::NONE)
    {}
 
public:
    Builder & seats(const std::string &pProductName, std::int64_t numSeats)
    {
        buildArgument();
        startArgument(::tenduke::se::licensing::License::SEATS, pProductName, numSeats);
        return static_cast<Builder&>(*this);
    }

    Builder & seat(const std::string &pProductName)
    {
        return seats(pProductName, 1);
    }

    Builder & count(const std::string &pProductName, std::int64_t useCount)
    {
        buildArgument();
        startArgument(::tenduke::se::licensing::License::USE_COUNT, pProductName, useCount);
        return static_cast<Builder&>(*this);
    }

    Builder & count(const std::string &pProductName)
    {
        return count(pProductName, 1);
    }

    Builder & time(const std::string &pProductName, std::int64_t useTime)
    {
        buildArgument();
        startArgument(::tenduke::se::licensing::License::USE_TIME, pProductName, useTime);
        return static_cast<Builder&>(*this);
    }

    Builder & version(const std::string &pClientVersion)
    {
        if (buildingItem) {
            this->clientVersion = pClientVersion;
        }
        else {
            defaultVersion = pClientVersion;
        }
        return static_cast<Builder&>(*this);
    }

    Builder & licenseId(const std::string &pLicenseId)
    {
        this->id = pLicenseId;
        return static_cast<Builder&>(*this);
    }
 
protected:
    void buildArgument()
    {
        if (buildingItem) {
            arguments.emplace_back(
                    productName,
                    qty,
                    qtyDimension,
                    clientVersion,
                    id
            );
            buildingItem = false;
        }
    }

    void startArgument(
            ::tenduke::se::licensing::License::QuantityDimension pQtyDimension,
            const std::string &pProductName,
            std::int64_t pQty
    )
    {
        this->buildingItem = true;
        this->qtyDimension = pQtyDimension;
        this->productName = pProductName;
        this->qty = pQty;
 
        this->id = "";
        this->clientVersion = defaultVersion;
    }
 
protected:
    const std::string licenseKey;

    std::vector<::tenduke::se::licensing::LicenseCheckoutArguments> arguments;
 
private:
    bool buildingItem;
    std::string defaultVersion;
 
    ::tenduke::se::licensing::License::QuantityDimension qtyDimension;
    std::string clientVersion;
    std::int64_t qty;
    std::string productName;
    std::string id;
};
 
}}}
 
#endif //TENDUKE_SE_LICENSING_FLUENTCONSUMPTIONBUILDER_H