@licensespring/node-sdk 1.0.2

package/dist/src/license.js

@@ -0,0 +1,630 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dayjs_1 = __importDefault(require("dayjs"));
+const utc_js_1 = __importDefault(require("dayjs/plugin/utc.js"));
+const isSameOrAfter_js_1 = __importDefault(require("dayjs/plugin/isSameOrAfter.js"));
+const offline_activation_1 = __importDefault(require("./offline-activation"));
+dayjs_1.default.extend(utc_js_1.default);
+dayjs_1.default.extend(isSameOrAfter_js_1.default);
+class License {
+    constructor(productCode, licenseAPI, licenseFile, floatingAPI) {
+        this.productCode = productCode;
+        this.licenseAPI = licenseAPI;
+        this.licenseFile = licenseFile;
+        this.floatingAPI = floatingAPI;
+    }
+    get isAirGapped() {
+        return this.licenseFile.licenseDataCache.license.is_air_gapped;
+    }
+    get policyID() {
+        return this.licenseFile.licenseDataCache.license.policy_id;
+    }
+    get isFloatingExpired() {
+        if (this.licenseFile.licenseDataCache.isFloatingLicense) {
+            return (0, dayjs_1.default)(this.licenseFile.licenseDataCache.floatingPeriod).utc().isAfter((0, dayjs_1.default)().utc());
+        }
+        return false;
+    }
+    get isValidityPeriodExpired() {
+        if (this.licenseFile.licenseDataCache.license.is_expired) {
+            return true;
+        }
+        if (this.validityWithGracePeriod) {
+            if ((0, dayjs_1.default)(this.validityWithGracePeriod).utc().isAfter((0, dayjs_1.default)().utc())) {
+                this.licenseFile.licenseDataCache.license.is_expired = true;
+                return true;
+            }
+        }
+        return false;
+    }
+    get validityPeriod() {
+        var _a;
+        return (_a = this.licenseFile.licenseDataCache.license.validity_period) !== null && _a !== void 0 ? _a : null;
+    }
+    get validityWithGracePeriod() {
+        var _a;
+        return (_a = this.licenseFile.licenseDataCache.validityWithGracePeriod) !== null && _a !== void 0 ? _a : null;
+    }
+    get licenseUser() {
+        var _a;
+        return (_a = this.licenseFile.licenseDataCache.license.user) !== null && _a !== void 0 ? _a : null;
+    }
+    get licenseKey() {
+        var _a;
+        return (_a = this.licenseFile.licenseDataCache.license.license_key) !== null && _a !== void 0 ? _a : null;
+    }
+    get isGracePeriodStarted() {
+        return (0, dayjs_1.default)(this.licenseFile.licenseDataCache.license.grace_period).utc().isBefore((0, dayjs_1.default)('2099-01-01').utc());
+    }
+    get gracePeriodHoursRemaining() {
+        return (0, dayjs_1.default)(this.licenseFile.licenseDataCache.gracePeriodEndDate).utc().diff((0, dayjs_1.default)().utc(), 'hours');
+    }
+    get maintenanceDaysRemaining() {
+        return (this.licenseFile.licenseDataCache.license.maintenance_period != null
+            ? (0, dayjs_1.default)(this.licenseFile.licenseDataCache.license.maintenance_period).utc().diff((0, dayjs_1.default)().utc(), 'days')
+            : null);
+    }
+    get daysRemaining() {
+        return (this.validityPeriod != null
+            ? (0, dayjs_1.default)(this.validityWithGracePeriod).utc().diff((0, dayjs_1.default)().utc(), 'days')
+            : null);
+    }
+    get customerInformation() {
+        return this.licenseFile.licenseDataCache.license.customer;
+    }
+    get id() {
+        return this.licenseFile.licenseDataCache.license.id;
+    }
+    get maxTransfers() {
+        return this.licenseFile.licenseDataCache.license.max_transfers;
+    }
+    get transferCount() {
+        return this.licenseFile.licenseDataCache.license.transfer_count;
+    }
+    get isDeviceTransferAllowed() {
+        return this.licenseFile.licenseDataCache.license.max_transfers != -1;
+    }
+    get isDeviceTransferLimited() {
+        return this.licenseFile.licenseDataCache.license.max_transfers != 0;
+    }
+    get daysSinceLastCheck() {
+        return (0, dayjs_1.default)(this.licenseFile.licenseDataCache.lastCheck).diff((0, dayjs_1.default)().utc(), 'days');
+    }
+    get startDate() {
+        return this.licenseFile.licenseDataCache.license.start_date;
+    }
+    get maintenancePeriod() {
+        return this.licenseFile.licenseDataCache.license.maintenance_period;
+    }
+    get isMaintenancePeriodExpired() {
+        return (0, dayjs_1.default)(this.licenseFile.licenseDataCache.license.maintenance_period).utc().isAfter((0, dayjs_1.default)().utc());
+    }
+    get lastCheck() {
+        return this.licenseFile.licenseDataCache.lastCheck;
+    }
+    get lastUsage() {
+        return this.licenseFile.licenseDataCache.lastUsage;
+    }
+    get licenseType() {
+        return this.licenseFile.licenseDataCache.license.license_type;
+    }
+    get maxActivations() {
+        return this.licenseFile.licenseDataCache.license.max_activations;
+    }
+    get metadata() {
+        return this.licenseFile.licenseDataCache.license.metadata;
+    }
+    get allowUnlimitedActivations() {
+        return this.licenseFile.licenseDataCache.license.allow_unlimited_activations;
+    }
+    get allowGraceSubscriptionPeriod() {
+        return this.licenseFile.licenseDataCache.license.allow_grace_period;
+    }
+    get isSubcriptionGracePeriodStarted() {
+        if (!this.subscriptionGracePeriod)
+            return false;
+        return (0, dayjs_1.default)(this.licenseFile.licenseDataCache.license.validity_period).isAfter((0, dayjs_1.default)().utc());
+    }
+    get gracePeriod() {
+        return this.licenseFile.licenseDataCache.gracePeriod;
+    }
+    get subscriptionGracePeriod() {
+        var _a;
+        return (_a = this.licenseFile.licenseDataCache.license.grace_period) !== null && _a !== void 0 ? _a : null;
+    }
+    get isExpired() {
+        return this.licenseFile.licenseDataCache.license.is_expired;
+    }
+    get licenseEnabled() {
+        return this.licenseFile.licenseDataCache.license.license_enabled;
+    }
+    get licenseActive() {
+        return this.licenseFile.licenseDataCache.license.license_active;
+    }
+    get isValid() {
+        return this.licenseFile.licenseDataCache.license.license_enabled &&
+            this.licenseFile.licenseDataCache.license.license_active &&
+            !this.licenseFile.licenseDataCache.license.is_expired;
+    }
+    get preventVm() {
+        return this.licenseFile.licenseDataCache.license.prevent_vm;
+    }
+    get isTrial() {
+        return this.licenseFile.licenseDataCache.license.is_trial;
+    }
+    get floatingTimeout() {
+        return this.licenseFile.licenseDataCache.license.floating_timeout;
+    }
+    get isFloating() {
+        return this.licenseFile.licenseDataCache.isFloatingLicense;
+    }
+    get floatingClientId() {
+        return this.licenseAPI.getHardwareID();
+    }
+    get isControlledByFloatingServer() {
+        return this.licenseFile.licenseDataCache.license.is_floating;
+    }
+    get expiryDate() {
+        return this.licenseFile.licenseDataCache.floatingPeriod;
+    }
+    get borrowUntil() {
+        return this.licenseFile.licenseDataCache.license.borrowed_until;
+    }
+    get isBorrowed() {
+        return this.licenseFile.licenseDataCache.license.is_borrowed;
+    }
+    get floatingInUseDevices() {
+        var _a;
+        return (_a = this.licenseFile.licenseDataCache.license.floating_in_use_devices) !== null && _a !== void 0 ? _a : null;
+    }
+    get floatingEndDate() {
+        var _a;
+        return (_a = this.licenseFile.licenseDataCache.floatingPeriod) !== null && _a !== void 0 ? _a : null;
+    }
+    get maxFloatingUsers() {
+        var _a;
+        return (_a = this.licenseFile.licenseDataCache.license.floating_users) !== null && _a !== void 0 ? _a : null;
+    }
+    get localConsumptions() {
+        var _a;
+        return (_a = this.licenseFile.licenseDataCache.localConsumptions) !== null && _a !== void 0 ? _a : null;
+    }
+    get maxConsumptions() {
+        var _a;
+        return (_a = this.licenseFile.licenseDataCache.license.max_consumptions) !== null && _a !== void 0 ? _a : null;
+    }
+    get totalConsumptions() {
+        var _a;
+        return (_a = this.licenseFile.licenseDataCache.license.total_consumptions) !== null && _a !== void 0 ? _a : null;
+    }
+    get maxOverages() {
+        return this.licenseFile.licenseDataCache.license.max_overages;
+    }
+    get allowUnlimitedConsumptions() {
+        var _a;
+        return (_a = this.licenseFile.licenseDataCache.license.allow_unlimited_consumptions) !== null && _a !== void 0 ? _a : null;
+    }
+    get consumptionReset() {
+        var _a;
+        return (_a = this.licenseFile.licenseDataCache.license.reset_consumption) !== null && _a !== void 0 ? _a : null;
+    }
+    get allowOverages() {
+        return this.licenseFile.licenseDataCache.license.allow_overages;
+    }
+    get consumptionPeriod() {
+        var _a;
+        return (_a = this.licenseFile.licenseDataCache.license.consumption_period) !== null && _a !== void 0 ? _a : null;
+    }
+    featureData(featureCode) {
+        return this.licenseFile.licenseDataCache.getFeature(featureCode);
+    }
+    get features() {
+        return this.licenseFile.licenseDataCache.license.product_features;
+    }
+    get customFields() {
+        return this.licenseFile.licenseDataCache.license.custom_fields;
+    }
+    checkLicenseStatus() {
+        const license = this.licenseFile.licenseDataCache.license;
+        if (!license.license_enabled) {
+            throw { status: 400, code: 'license_not_enabled', message: 'The license is not enabled' };
+        }
+        if (!license.license_active) {
+            throw { status: 400, code: 'license_not_active', message: 'The license is not active' };
+        }
+        if (license.validity_period) {
+            if ((0, dayjs_1.default)().utc().startOf('day').isSameOrAfter(license.validity_period)) {
+                throw { status: 400, code: 'license_expired', message: 'The license is expired' };
+            }
+        }
+    }
+    check() {
+        return __awaiter(this, arguments, void 0, function* (includeExpiredFeatures = false) {
+            try {
+                if (this.isControlledByFloatingServer) {
+                    const response = yield this.floatingAPI.registerUser(undefined, this.licenseFile.licenseDataCache.license.id, undefined, this.licenseFile.licenseDataCache.productCode);
+                    this.licenseFile.licenseDataCache.updateCache('floating_server_register', response);
+                    this.licenseFile.saveLicenseFile();
+                    this.checkLicenseStatus();
+                    return response;
+                }
+                else {
+                    const payload = this.getLicenseIDPayload();
+                    const response = yield this.licenseAPI.checkLicense(payload, includeExpiredFeatures);
+                    this.licenseFile.licenseDataCache.updateCache('check_license', response);
+                    this.licenseFile.licenseDataCache.updateFloatingPeriod(this.licenseFile.licenseDataCache.license.borrowed_until || null);
+                    for (const featureName in this.licenseFile.licenseDataCache.features) {
+                        this.syncFeatureConsumption(this.licenseFile.licenseDataCache.features[featureName]);
+                    }
+                    if (this.licenseFile.licenseDataCache.license.license_type == 'consumption') {
+                        this.syncConsumption();
+                    }
+                    if (this.licenseFile.licenseDataCache.isGracePeriodStarted) {
+                        this.licenseFile.licenseDataCache.gracePeriodStartDate = (0, dayjs_1.default)('2099-01-01').utc().toISOString();
+                    }
+                    this.licenseFile.saveLicenseFile();
+                    this.checkLicenseStatus();
+                    return response;
+                }
+            }
+            catch (error) {
+                if (this.licenseFile.licenseDataCache.isFloatingLicense || this.licenseFile.licenseDataCache.isActiveFloatingCloud) {
+                    return null;
+                }
+                throw error;
+            }
+        });
+    }
+    getLicenseIDPayload() {
+        var _a;
+        const payload = {
+            license_id: this.licenseFile.licenseDataCache.license.id,
+            product: this.licenseFile.licenseDataCache.productCode,
+            hardware_id: this.licenseFile.licenseDataCache.hardwareID,
+        };
+        if (this.licenseFile.licenseDataCache.bundleCode) {
+            payload.bundle_code = this.licenseFile.licenseDataCache.bundleCode;
+        }
+        if (this.licenseFile.licenseDataCache.license.license_key) {
+            payload.license_key = this.licenseFile.licenseDataCache.license.license_key;
+        }
+        if ((_a = this.licenseFile.licenseDataCache.license.user) === null || _a === void 0 ? void 0 : _a.email) {
+            payload.username = this.licenseFile.licenseDataCache.license.user.email;
+        }
+        return payload;
+    }
+    getDeactivationCode(initializationCode) {
+        return this.licenseAPI.getAirGapActivationCode(initializationCode, this.licenseFile.licenseDataCache.license.license_key);
+    }
+    deactivateAirGap(confirmationCode) {
+        if (!this.licenseAPI.verifyConfirmationCode(confirmationCode, this.licenseFile.licenseDataCache.license.license_key, this.licenseFile.licenseDataCache.policyId)) {
+            throw { status: 400, code: 'air_gap_activation_error', message: 'Error verifying airgap code' };
+        }
+        this.licenseFile.licenseDataCache.deactivate();
+        this.licenseFile.clearStorage();
+    }
+    deactivate() {
+        return __awaiter(this, arguments, void 0, function* (deleteLicense = false) {
+            if (!this.licenseActive) {
+                if (deleteLicense) {
+                    this.licenseFile.deleteLicenseFile();
+                }
+                return false;
+            }
+            if (this.isControlledByFloatingServer) {
+                return yield this.floatingAPI.unregisterUser(undefined, this.licenseFile.licenseDataCache.license.id, this.licenseFile.licenseDataCache.productCode);
+            }
+            const payload = this.getLicenseIDPayload();
+            yield this.licenseAPI.deactivateLicense(payload);
+            if (deleteLicense) {
+                this.licenseFile.deleteLicenseFile();
+                return true;
+            }
+            this.licenseFile.licenseDataCache.deactivate();
+            this.licenseFile.saveLicenseFile();
+        });
+    }
+    localCheck() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.licenseAPI.getHardwareID() != this.licenseFile.licenseDataCache.hardwareID) {
+                throw { status: 500, code: 'hardware_id_mismatch', message: 'License file does not belong to this device' };
+            }
+            if (this.productCode != this.licenseFile.licenseDataCache.productCode) {
+                throw { status: 500, code: 'product_mismatch', message: 'License file does not belong to this product' };
+            }
+            this.checkLicenseStatus();
+            if (this.isFloatingExpired) {
+                throw { status: 400, code: 'floating_timeout', message: 'Floating license timeout expired' };
+            }
+            if ((0, dayjs_1.default)(this.lastUsage).utc().isAfter((0, dayjs_1.default)().utc())) {
+                throw { status: 400, code: 'clock_tampered', message: 'Local clock mismatch' };
+            }
+            return true;
+        });
+    }
+    changePassword(oldPassword, newPassword) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if ((_a = this.licenseFile.licenseDataCache.license.user) === null || _a === void 0 ? void 0 : _a.email) {
+                this.checkLicenseStatus();
+                return yield this.licenseAPI.changePassword({
+                    username: this.licenseFile.licenseDataCache.license.user.email,
+                    password: oldPassword,
+                    new_password: newPassword,
+                });
+            }
+        });
+    }
+    addLocalConsumption(consumptions = 1) {
+        this.licenseFile.licenseDataCache.updateConsumption(consumptions);
+    }
+    addLocalFeatureConsumption(featureCode, consumptions = 1) {
+        this.licenseFile.licenseDataCache.updateFeatureConsumption(featureCode, consumptions);
+    }
+    syncFeatureConsumption(feature) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storedFeature = this.licenseFile.licenseDataCache.features[feature.code];
+            if (!storedFeature || storedFeature.local_consumption == 0) {
+                return false;
+            }
+            try {
+                let response;
+                if (this.isControlledByFloatingServer) {
+                    response = yield this.floatingAPI.addFeatureConsumption(feature.code, storedFeature.local_consumption, this.licenseFile.licenseDataCache.license.id, this.licenseFile.licenseDataCache.productCode);
+                }
+                else {
+                    const payload = this.getLicenseIDPayload();
+                    payload.feature = feature.code;
+                    payload.consumptions = storedFeature.local_consumption;
+                    response = yield this.licenseAPI.addFeatureConsumption(payload);
+                }
+                this.licenseFile.licenseDataCache.updateCache('feature_consumption', response, feature.code);
+                if (this.licenseFile.licenseDataCache.isGracePeriodStarted) {
+                    this.licenseFile.licenseDataCache.gracePeriodStartDate = (0, dayjs_1.default)('2099-01-01').utc().toISOString();
+                }
+                this.licenseFile.saveLicenseFile();
+            }
+            catch (error) {
+                if (this.isGracePeriodException()) {
+                    this.licenseFile.saveLicenseFile();
+                    this.checkLicenseStatus();
+                    return false;
+                }
+                throw error;
+            }
+            return true;
+        });
+    }
+    syncConsumption() {
+        return __awaiter(this, arguments, void 0, function* (overages = -1) {
+            if (this.licenseFile.licenseDataCache.localConsumptions == null) {
+                return false;
+            }
+            if (this.licenseFile.licenseDataCache.localConsumptions == 0 && overages < 0) {
+                return false;
+            }
+            const maxOverages = overages >= 0 ? overages : null;
+            const allowOverages = overages == 0 ? false : overages > 0 ? true : null;
+            try {
+                let response;
+                if (this.isControlledByFloatingServer) {
+                    response = yield this.floatingAPI.addConsumption(this.licenseFile.licenseDataCache.localConsumptions, this.licenseFile.licenseDataCache.license.id, maxOverages, allowOverages, this.licenseFile.licenseDataCache.productCode);
+                }
+                else {
+                    const payload = this.getLicenseIDPayload();
+                    payload.consumptions = this.licenseFile.licenseDataCache.localConsumptions;
+                    payload.max_overages = maxOverages;
+                    payload.allow_overages = allowOverages;
+                    response = yield this.licenseAPI.addConsumption(payload);
+                }
+                this.licenseFile.licenseDataCache.updateCache('license_consumption', response);
+                if (this.licenseFile.licenseDataCache.isGracePeriodStarted) {
+                    this.licenseFile.licenseDataCache.gracePeriodStartDate = (0, dayjs_1.default)('2099-01-01').utc().toISOString();
+                }
+                this.licenseFile.saveLicenseFile();
+            }
+            catch (error) {
+                if (this.isGracePeriodException()) {
+                    this.licenseFile.saveLicenseFile();
+                    this.checkLicenseStatus();
+                    return false;
+                }
+                throw error;
+            }
+            return true;
+        });
+    }
+    get isGracePeriod() {
+        if (!this.licenseFile.licenseDataCache.gracePeriod) {
+            return false;
+        }
+        this.licenseFile.licenseDataCache.updateGracePeriodStartDate();
+        return (0, dayjs_1.default)(this.licenseFile.licenseDataCache.gracePeriodEndDate).utc().isAfter((0, dayjs_1.default)().utc());
+    }
+    floatingBorrow(borrowUntil, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.licenseFile.licenseDataCache.isFloatingLicense) {
+                return false;
+            }
+            let response;
+            if (this.isControlledByFloatingServer) {
+                response = yield this.floatingAPI.borrow(borrowUntil, this.licenseFile.licenseDataCache.license.id, this.licenseFile.licenseDataCache.productCode);
+            }
+            else {
+                const payload = this.getLicenseIDPayload();
+                payload.borrowed_until = borrowUntil;
+                if (password) {
+                    payload.password = password;
+                }
+                response = yield this.licenseAPI.floatingBorrow(payload);
+            }
+            this.licenseFile.licenseDataCache.license.is_borrowed = true;
+            this.licenseFile.licenseDataCache.updateCache('normal', response);
+            this.licenseFile.licenseDataCache.updateFloatingPeriod(this.licenseFile.licenseDataCache.license.borrowed_until);
+            this.licenseFile.saveLicenseFile();
+            return true;
+        });
+    }
+    floatingRelease() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.licenseFile.licenseDataCache.isFloatingLicense) {
+                return false;
+            }
+            this.checkLicenseStatus();
+            if (this.isControlledByFloatingServer) {
+                yield this.floatingAPI.unregisterUser(undefined, this.licenseFile.licenseDataCache.license.id, this.licenseFile.licenseDataCache.productCode);
+            }
+            else {
+                const payload = this.getLicenseIDPayload();
+                yield this.licenseAPI.floatingRelease(payload);
+            }
+            this.licenseFile.licenseDataCache.releaseLicense();
+            this.licenseFile.saveLicenseFile();
+            return true;
+        });
+    }
+    checkFeature(featureCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let response;
+            if (this.isControlledByFloatingServer) {
+                response = yield this.floatingAPI.registerFeature(featureCode, this.licenseFile.licenseDataCache.license.id, this.licenseFile.licenseDataCache.productCode);
+            }
+            else {
+                const payload = this.getLicenseIDPayload();
+                payload.feature = featureCode;
+                response = yield this.licenseAPI.checkLicenseFeature(payload);
+            }
+            this.licenseFile.licenseDataCache.registerFeature(featureCode);
+            this.licenseFile.licenseDataCache.updateCache('register_feature', response, featureCode);
+            this.licenseFile.saveLicenseFile();
+        });
+    }
+    releaseFeature(featureCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isControlledByFloatingServer) {
+                yield this.floatingAPI.featureRelease(featureCode, this.licenseFile.licenseDataCache.license.id, this.licenseFile.licenseDataCache.productCode);
+            }
+            else {
+                const payload = this.getLicenseIDPayload();
+                payload.feature = featureCode;
+                yield this.licenseAPI.featureRelease(payload);
+            }
+            this.licenseFile.licenseDataCache.releaseFeature(featureCode);
+            this.licenseFile.saveLicenseFile();
+        });
+    }
+    updateOffline(path, resetConsumption) {
+        const data = this.licenseFile.loadOfflineLicense(path);
+        const decodedData = this.licenseAPI.checkLicenseOffline(data);
+        if (decodedData.hardware_id != this.licenseFile.licenseDataCache.hardwareID) {
+            throw { status: 500, code: 'hardware_id_mismatch', message: 'License file does not belong to this device' };
+        }
+        if (decodedData.product != this.licenseFile.licenseDataCache.productCode) {
+            throw { status: 500, code: 'product_mismatch', message: 'License file does not belong to this product' };
+        }
+        if (resetConsumption && this.licenseFile.licenseDataCache.license.license_type == 'consumption') {
+            this.licenseFile.licenseDataCache.resetLocalConsumption();
+        }
+        this.licenseFile.licenseDataCache.updateCache('update_license_offline', decodedData);
+        this.licenseFile.saveLicenseFile();
+        return true;
+    }
+    deactivateOffline(offlinePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.licenseFile.licenseDataCache.deactivate();
+            const response = yield this.licenseAPI.deactivateOffline(Object.assign(Object.assign({}, this.licenseFile.licenseDataCache.getIdentificator()), { product: this.productCode, hardware_id: this.licenseFile.licenseDataCache.hardwareID, bundle_code: this.licenseFile.licenseDataCache.bundleCode, license_id: this.licenseFile.licenseDataCache.license.id }));
+            const offlineData = new offline_activation_1.default();
+            offlineData.isActivation = false;
+            offlineData.data = response;
+            this.licenseFile.createRequestFile(offlineData, offlinePath);
+        });
+    }
+    productDetails() {
+        return __awaiter(this, arguments, void 0, function* (includeLatestVersion = false, includeCustomFields = false, includeExpiredFeatures = false) {
+            const response = yield this.licenseAPI.getProductDetails({
+                product: this.productCode,
+                include_latest_version: includeLatestVersion,
+                include_custom_fields: includeCustomFields,
+                include_expired_features: includeExpiredFeatures,
+            });
+            this.licenseFile.licenseDataCache.updateCache('product_details', response);
+            this.licenseFile.saveLicenseFile();
+            return response;
+        });
+    }
+    get productDetailsLocal() {
+        return this.licenseFile.licenseDataCache.license.product_details;
+    }
+    setDeviceVariablesLocal(variables, save = true) {
+        this.licenseFile.licenseDataCache.variables = [];
+        for (const key in variables) {
+            this.licenseFile.licenseDataCache.variables.push({ variable: key, value: String(variables[key]) });
+        }
+        if (save) {
+            this.licenseFile.saveLicenseFile();
+        }
+    }
+    setDeviceVariables() {
+        return __awaiter(this, arguments, void 0, function* (save = false) {
+            try {
+                const variables = {};
+                if (!this.licenseFile.licenseDataCache.variables.length) {
+                    return false;
+                }
+                this.licenseFile.licenseDataCache.variables.map(item => { variables[item.variable] = item.value; });
+                this.licenseAPI.trackDeviceVariables(Object.assign(Object.assign({}, this.licenseFile.licenseDataCache.getIdentificator()), { product: this.productCode, hardware_id: this.licenseFile.licenseDataCache.hardwareID, bundle_code: this.licenseFile.licenseDataCache.bundleCode, license_id: this.licenseFile.licenseDataCache.license.id, variables }));
+                if (save) {
+                    this.licenseFile.saveLicenseFile();
+                }
+            }
+            catch (e) {
+                if (this.isGracePeriod) {
+                    return false;
+                }
+                throw e;
+            }
+        });
+    }
+    getDeviceVariableLocal(variable) {
+        return (this.licenseFile.licenseDataCache.variables.filter(item => item.variable == variable) || [])[0];
+    }
+    getDeviceVariablesLocal() {
+        return this.licenseFile.licenseDataCache.variables;
+    }
+    getDeviceVariables() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.licenseAPI.getDeviceVariables(Object.assign(Object.assign({}, this.licenseFile.licenseDataCache.getIdentificator()), { product: this.productCode, hardware_id: this.licenseFile.licenseDataCache.hardwareID, bundle_code: this.licenseFile.licenseDataCache.bundleCode, license_id: this.licenseFile.licenseDataCache.license.id }));
+                this.licenseFile.licenseDataCache.updateCache('device_variables', response);
+                this.licenseFile.saveLicenseFile();
+            }
+            catch (e) {
+                if (this.isGracePeriod) {
+                    return null;
+                }
+                throw e;
+            }
+        });
+    }
+    isGracePeriodException() {
+        if (!this.licenseAPI.config.gracePeriod) {
+            return false;
+        }
+        this.licenseFile.licenseDataCache.updateGracePeriodStartDate();
+        return (0, dayjs_1.default)(this.licenseFile.licenseDataCache.gracePeriodEndDate).utc().isAfter((0, dayjs_1.default)().utc());
+    }
+}
+exports.default = License;
+//# sourceMappingURL=license.js.map