KeyzyTypes.h

Go to the documentation of this file.

#ifndef KEYZY_TYPES_H
#define KEYZY_TYPES_H

 
#include <string>
#include <ctime>
#include <stdexcept>
 
namespace Keyzy
{
    enum class HostIdScheme
    {
        V1 = 1, 
        V2 = 2  
    };

    enum class HostIdMigrationMode
    {
        SemiOnline = 1, 
        Online = 2      
    };

    enum class HostIdMigrationState
    {
        AlreadyV2 = 1,          
        Moved = 2,              
        StayedOnV1 = 3,         
        Interrupted = 4,        
        NothingToMove = 5,      
        WrongHostIdScheme = 6,  
        NotNeededOnPlatform = 7 
    };

    class CannotReadHostIdError : public std::runtime_error
    {
    public:
        CannotReadHostIdError() : std::runtime_error("Cannot read host id") {}
    };

    struct ProductData
    {
        ProductData() : _useHostIdInOffilneActivation(true), _hostIdScheme(HostIdScheme::V2) {}

        ProductData(std::string appId, std::string apiKey, std::string productCode,
                    std::string cryptionKey, bool useHostIdInOfflineActivation = true,
                    HostIdScheme hostIdScheme = HostIdScheme::V2)
        : _appId(appId)
        , _apiKey(apiKey)
        , _productCode(productCode)
        , _cryptionKey(cryptionKey)
        , _useHostIdInOffilneActivation(useHostIdInOfflineActivation)
        , _hostIdScheme(hostIdScheme) {}
 
        std::string _appId;
        std::string _apiKey;
        std::string _productCode;
        std::string _cryptionKey;
        bool _useHostIdInOffilneActivation;
        HostIdScheme _hostIdScheme;
    };

    struct LicenseInfo
    {
        std::string _skuNumber;
        std::string _productCode;
        std::string _licenseeName;
        std::string _licenseeEmail;
        std::string _versionCode;
        std::string _licenseType;
        std::int64_t _startTime = 315522000;
        std::int64_t _endTime = 315522000;
        std::string _info;
        std::string _serialNumber;
    };

    enum class LicenseStatus
    {
        VALID,             
        EXPIRED,           
        INVALID,           
        NOT_AUTHORIZED,             
        SERIAL_INVALID,             
        PRODUCT_NOT_EXIST,          
        PRODUCT_NOT_EXIST_FOR_USER, 
        PRODUCT_NOT_ACTIVE,         
        SKU_NOT_EXIST,              
        SKU_NOT_ACTIVE,             
        REACHED_MAX_NUMBER_OF_HOST, 
        PRODUCT_NOT_EXIST_FOR_SKU,  
        ACTIVATION_DEACTIVATED,           
        SUBSCRIPTION_LICENSE_EXPIRED,     
        SUBSCRIPTION_LICENSE_NOT_STARTED, 
        TRIAL_LICENSE_EXPIRED,            
        TRIAL_LICENSE_NOT_STARTED,        
        CANNOT_KEEP_SERIAL,           
        CANNOT_KEEP_LICENSE_FILE,     
        ACTIVATION_DELETED, 
        CLIENT_SERIAL_DOES_NOT_EXIST, 
        CONNECTION_ERROR,             
        TOO_MANY_REQUESTS,          
        NO_ACTIVE_SUBSCRIPTION,     
        CURRENT_LICENSE_DOES_NOT_EXIST, 
        UPGRADE_LICENSE_DOES_NOT_EXIST, 
        UPGRADE_LICENSE_DOES_NOT_MATCH, 
        ANOTHER_TRIAL_LICENSE_ALREADY_ACTIVATED, 
        SKU_NUMBER_VALIDATION,   
        PRODUCT_CODE_VALIDATION, 
        NAME_VALIDATION,         
        EMAIL_VALIDATION,        
        NO_FREE_LICENSES,           
        NAME_OR_EMAIL_VALIDATION,   
        LICENSE_NOT_EXIST_NOT_ASSIGNED_DEALER_ALREADY_DEPOSITED, 
        SERIAL_VALIDATION,       
        CODE_VALIDATION,         
 
        // Network diagnostic statuses (SDK 1.9.0+). All are client-detected and
        // returned by any method that makes a network request, when the call fails
        // at the network layer (see the README error table for the full method list).
        NETWORK_DNS_FAILED,        
        NETWORK_REFUSED,           
        NETWORK_TIMEOUT,           
        NETWORK_TLS_FAILED,        
        NETWORK_PROXY_REQUIRED,    
        NETWORK_HOSTS_TAMPERED,     
 
        CANNOT_READ_HOST_ID         
    };

    struct HostIdMigrationResult
    {
        LicenseStatus status;        
        HostIdMigrationState state;  
    };

    enum class LicenseType
    {
        NOTYPE,
        PERPETUAL,
        TRIAL,
        SUBSCRIPTION
    };
 
}; // Keyzy
 
#endif // KEYZY_TYPES_H