License.h

#ifndef TENDUKE_SE_LICENSING_LICENSE_H
#define TENDUKE_SE_LICENSING_LICENSE_H
 
#include "./LicenseFeature.h"
#include "./LicenseKey.h"
 
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
namespace tenduke { namespace se { namespace licensing {
 
const char QTY_DIMENSION_SEATS[] = "SEATS";
const char QTY_DIMENSION_USE_COUNT[] = "USE_COUNT";
const char QTY_DIMENSION_USE_TIME[] = "USE_TIME";
const char QTY_DIMENSION_NONE[] = "NONE";
 
class License
{
public:
    enum QuantityDimension
    {
        NONE = -1,
        SEATS = 0,
        USE_COUNT,
        USE_TIME
    };
 
    static const char * dimensionToString(enum QuantityDimension quantityDimension)
    {
        switch(quantityDimension) {
            case SEATS: return QTY_DIMENSION_SEATS;
            case USE_COUNT: return QTY_DIMENSION_USE_COUNT;
            case USE_TIME: return QTY_DIMENSION_USE_TIME;
            default: return QTY_DIMENSION_NONE;
        }
    }
 
    static enum QuantityDimension stringToDimension(const std::string &string)
    {
        if (string == QTY_DIMENSION_SEATS) {
            return QuantityDimension::SEATS;
        }
        if (string == QTY_DIMENSION_USE_COUNT) {
            return QuantityDimension::USE_COUNT;
        }
        if (string == QTY_DIMENSION_USE_TIME) {
            return QuantityDimension::USE_TIME;
        }
        return QuantityDimension::NONE;
    }
 
public:
    License(
            std::string allowedVersionLowerBound
          , std::string allowedVersionUpperBound
          , std::string allowedVersionsDisplayName
          , const std::int64_t concurrentUserAppInstancesPerSeat
          , const std::int64_t concurrentUserDevicesPerSeat
          , std::string created
          , std::string displayName
          , std::string featureNames
          , const std::vector<::tenduke::se::licensing::LicenseFeature> &features
          , std::string id
          , std::string modified
          , std::string productName
          , const std::int64_t qty
          , const enum QuantityDimension qtyDimension
          , std::string qtyEnforcementType
          , std::string validFrom
          , std::string validUntil
          , const std::shared_ptr<const ::tenduke::se::licensing::LicenseKey> &licenseKey = nullptr
    ) : allowedVersionLowerBound(std::move(allowedVersionLowerBound))
      , allowedVersionUpperBound(std::move(allowedVersionUpperBound))
      , allowedVersionsDisplayName(std::move(allowedVersionsDisplayName))
      , concurrentUserAppInstancesPerSeat(concurrentUserAppInstancesPerSeat)
      , concurrentUserDevicesPerSeat(concurrentUserDevicesPerSeat)
      , created(std::move(created))
      , displayName(std::move(displayName))
      , featureNames(std::move(featureNames))
      , features(features)
      , id(std::move(id))
      , licenseKey(licenseKey)
      , modified(std::move(modified))
      , productName(std::move(productName))
      , qty(qty)
      , qtyDimension(qtyDimension)
      , qtyEnforcementType(std::move(qtyEnforcementType))
      , validFrom(std::move(validFrom))
      , validUntil(std::move(validUntil))
    {}
 
public:
    const std::string allowedVersionLowerBound;
    const std::string allowedVersionUpperBound;
    const std::string allowedVersionsDisplayName;
    const std::int64_t concurrentUserAppInstancesPerSeat;
    const std::int64_t concurrentUserDevicesPerSeat;
    const std::string created;
    const std::string displayName;
    const std::string featureNames;
    const std::vector<::tenduke::se::licensing::LicenseFeature> features;
    const std::string id;
    const std::shared_ptr<const ::tenduke::se::licensing::LicenseKey> licenseKey;
    //const std::shared_ptr<const tenduke::se::licensing::LicenseMetadata> licenseMetadata;
    const std::string modified;
    const std::string productName;
    const std::int64_t qty;
    const enum QuantityDimension qtyDimension;
    const std::string qtyEnforcementType;
    const std::string validFrom;
    const std::string validUntil;
};
 
 
}}}
 
#endif //TENDUKE_SE_LICENSING_LICENSE_H