@licensespring/node-sdk 1.1.18 → 1.2.0

package/dist/src/license.js

@@ -25,25 +25,28 @@ class License {
         this.licenseFile = licenseFile;
         this.floatingAPI = floatingAPI;
     }
+    get currentLicenseData() {
+        return this.licenseFile.licenseDataCache[this.productCode];
+    }
     get isAirGapped() {
-        return this.licenseFile.licenseDataCache.license.is_air_gapped;
+        return this.currentLicenseData.license.is_air_gapped;
     }
     get policyID() {
-        return this.licenseFile.licenseDataCache.license.policy_id;
+        return this.currentLicenseData.license.policy_id;
     }
     get isFloatingExpired() {
-        if (this.licenseFile.licenseDataCache.isFloatingLicense) {
-            return (0, dayjs_1.default)().utc().isAfter(this.licenseFile.licenseDataCache.floatingPeriod);
+        if (this.currentLicenseData.isFloatingLicense) {
+            return (0, dayjs_1.default)().utc().isAfter(this.currentLicenseData.floatingPeriod);
         }
         return false;
     }
     get isValidityPeriodExpired() {
-        if (this.licenseFile.licenseDataCache.license.is_expired) {
+        if (this.currentLicenseData.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;
+                this.currentLicenseData.license.is_expired = true;
                 return true;
             }
         }
@@ -51,29 +54,29 @@ class License {
     }
     get validityPeriod() {
         var _a;
-        return (_a = this.licenseFile.licenseDataCache.license.validity_period) !== null && _a !== void 0 ? _a : null;
+        return (_a = this.currentLicenseData.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;
+        return (_a = this.currentLicenseData.validityWithGracePeriod) !== null && _a !== void 0 ? _a : null;
     }
     get licenseUser() {
         var _a;
-        return (_a = this.licenseFile.licenseDataCache.license.user) !== null && _a !== void 0 ? _a : null;
+        return (_a = this.currentLicenseData.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;
+        return (_a = this.currentLicenseData.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());
+        return (0, dayjs_1.default)(this.currentLicenseData.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');
+        return (0, dayjs_1.default)(this.currentLicenseData.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')
+        return (this.currentLicenseData.license.maintenance_period != null
+            ? (0, dayjs_1.default)(this.currentLicenseData.license.maintenance_period).utc().diff((0, dayjs_1.default)().utc(), 'days')
             : null);
     }
     get daysRemaining() {
@@ -82,162 +85,162 @@ class License {
             : null);
     }
     get customerInformation() {
-        return this.licenseFile.licenseDataCache.license.customer;
+        return this.currentLicenseData.license.customer;
     }
     get id() {
-        return this.licenseFile.licenseDataCache.license.id;
+        return this.currentLicenseData.license.id;
     }
     get maxTransfers() {
-        return this.licenseFile.licenseDataCache.license.max_transfers;
+        return this.currentLicenseData.license.max_transfers;
     }
     get transferCount() {
-        return this.licenseFile.licenseDataCache.license.transfer_count;
+        return this.currentLicenseData.license.transfer_count;
     }
     get isDeviceTransferAllowed() {
-        return this.licenseFile.licenseDataCache.license.max_transfers != -1;
+        return this.currentLicenseData.license.max_transfers != -1;
     }
     get isDeviceTransferLimited() {
-        return this.licenseFile.licenseDataCache.license.max_transfers != 0;
+        return this.currentLicenseData.license.max_transfers != 0;
     }
     get daysSinceLastCheck() {
-        return (0, dayjs_1.default)(this.licenseFile.licenseDataCache.lastCheck).diff((0, dayjs_1.default)().utc(), 'days');
+        return (0, dayjs_1.default)(this.currentLicenseData.lastCheck).diff((0, dayjs_1.default)().utc(), 'days');
     }
     get startDate() {
-        return this.licenseFile.licenseDataCache.license.start_date;
+        return this.currentLicenseData.license.start_date;
     }
     get maintenancePeriod() {
-        return this.licenseFile.licenseDataCache.license.maintenance_period;
+        return this.currentLicenseData.license.maintenance_period;
     }
     get isMaintenancePeriodExpired() {
-        return (0, dayjs_1.default)(this.licenseFile.licenseDataCache.license.maintenance_period).utc().isAfter((0, dayjs_1.default)().utc());
+        return (0, dayjs_1.default)(this.currentLicenseData.license.maintenance_period).utc().isAfter((0, dayjs_1.default)().utc());
     }
     get lastCheck() {
-        return this.licenseFile.licenseDataCache.lastCheck;
+        return this.currentLicenseData.lastCheck;
     }
     get lastUsage() {
-        return this.licenseFile.licenseDataCache.lastUsage;
+        return this.currentLicenseData.lastUsage;
     }
     get licenseType() {
-        return this.licenseFile.licenseDataCache.license.license_type;
+        return this.currentLicenseData.license.license_type;
     }
     get maxActivations() {
-        return this.licenseFile.licenseDataCache.license.max_activations;
+        return this.currentLicenseData.license.max_activations;
     }
     get metadata() {
-        return this.licenseFile.licenseDataCache.license.metadata;
+        return this.currentLicenseData.license.metadata;
     }
     get allowUnlimitedActivations() {
-        return this.licenseFile.licenseDataCache.license.allow_unlimited_activations;
+        return this.currentLicenseData.license.allow_unlimited_activations;
     }
     get allowGraceSubscriptionPeriod() {
-        return this.licenseFile.licenseDataCache.license.allow_grace_period;
+        return this.currentLicenseData.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());
+        return (0, dayjs_1.default)(this.currentLicenseData.license.validity_period).isAfter((0, dayjs_1.default)().utc());
     }
     get gracePeriod() {
-        return this.licenseFile.licenseDataCache.gracePeriod;
+        return this.currentLicenseData.gracePeriod;
     }
     get subscriptionGracePeriod() {
         var _a;
-        return (_a = this.licenseFile.licenseDataCache.license.grace_period) !== null && _a !== void 0 ? _a : null;
+        return (_a = this.currentLicenseData.license.grace_period) !== null && _a !== void 0 ? _a : null;
     }
     get isExpired() {
-        return this.licenseFile.licenseDataCache.license.is_expired;
+        return this.currentLicenseData.license.is_expired;
     }
     get licenseEnabled() {
-        return this.licenseFile.licenseDataCache.license.license_enabled;
+        return this.currentLicenseData.license.license_enabled;
     }
     get licenseActive() {
-        return this.licenseFile.licenseDataCache.license.license_active;
+        return this.currentLicenseData.license.license_active;
     }
     get isValid() {
-        return this.licenseFile.licenseDataCache.license.license_enabled &&
-            this.licenseFile.licenseDataCache.license.license_active &&
-            !this.licenseFile.licenseDataCache.license.is_expired;
+        return this.currentLicenseData.license.license_enabled &&
+            this.currentLicenseData.license.license_active &&
+            !this.currentLicenseData.license.is_expired;
     }
     get preventVm() {
-        return this.licenseFile.licenseDataCache.license.prevent_vm;
+        return this.currentLicenseData.license.prevent_vm;
     }
     get isTrial() {
-        return this.licenseFile.licenseDataCache.license.is_trial;
+        return this.currentLicenseData.license.is_trial;
     }
     get floatingTimeout() {
-        return this.licenseFile.licenseDataCache.license.floating_timeout;
+        return this.currentLicenseData.license.floating_timeout;
     }
     get isFloating() {
-        return this.licenseFile.licenseDataCache.isFloatingLicense;
+        return this.currentLicenseData.isFloatingLicense;
     }
     get floatingClientId() {
         return this.licenseAPI.getHardwareID();
     }
     get isControlledByFloatingServer() {
-        return this.licenseFile.licenseDataCache.license.is_floating;
+        return this.currentLicenseData.license.is_floating;
     }
     get expiryDate() {
-        return this.licenseFile.licenseDataCache.floatingPeriod;
+        return this.currentLicenseData.floatingPeriod;
     }
     get borrowUntil() {
-        return this.licenseFile.licenseDataCache.license.borrowed_until;
+        return this.currentLicenseData.license.borrowed_until;
     }
     get isBorrowed() {
-        return this.licenseFile.licenseDataCache.license.is_borrowed;
+        return this.currentLicenseData.license.is_borrowed;
     }
     get floatingInUseDevices() {
         var _a;
-        return (_a = this.licenseFile.licenseDataCache.license.floating_in_use_devices) !== null && _a !== void 0 ? _a : null;
+        return (_a = this.currentLicenseData.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;
+        return (_a = this.currentLicenseData.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;
+        return (_a = this.currentLicenseData.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;
+        return (_a = this.currentLicenseData.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;
+        return (_a = this.currentLicenseData.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;
+        return (_a = this.currentLicenseData.license.total_consumptions) !== null && _a !== void 0 ? _a : null;
     }
     get maxOverages() {
-        return this.licenseFile.licenseDataCache.license.max_overages;
+        return this.currentLicenseData.license.max_overages;
     }
     get allowUnlimitedConsumptions() {
         var _a;
-        return (_a = this.licenseFile.licenseDataCache.license.allow_unlimited_consumptions) !== null && _a !== void 0 ? _a : null;
+        return (_a = this.currentLicenseData.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;
+        return (_a = this.currentLicenseData.license.reset_consumption) !== null && _a !== void 0 ? _a : null;
     }
     get allowOverages() {
-        return this.licenseFile.licenseDataCache.license.allow_overages;
+        return this.currentLicenseData.license.allow_overages;
     }
     get consumptionPeriod() {
         var _a;
-        return (_a = this.licenseFile.licenseDataCache.license.consumption_period) !== null && _a !== void 0 ? _a : null;
+        return (_a = this.currentLicenseData.license.consumption_period) !== null && _a !== void 0 ? _a : null;
     }
     featureData(featureCode) {
-        return this.licenseFile.licenseDataCache.getFeature(featureCode);
+        return this.currentLicenseData.getFeature(featureCode);
     }
     get features() {
-        return this.licenseFile.licenseDataCache.license.product_features;
+        return this.currentLicenseData.license.product_features;
     }
     get customFields() {
-        return this.licenseFile.licenseDataCache.license.custom_fields;
+        return this.currentLicenseData.license.custom_fields;
     }
     checkLicenseStatus() {
-        const license = this.licenseFile.licenseDataCache.license;
+        const license = this.currentLicenseData.license;
         if (!license.license_enabled) {
             throw { status: 400, code: 'license_not_enabled', message: 'The license is not enabled' };
         }
@@ -254,8 +257,8 @@ class License {
         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);
+                    const response = yield this.floatingAPI.registerUser(undefined, this.currentLicenseData.license.id, undefined, this.currentLicenseData.productCode);
+                    this.currentLicenseData.updateFloatingRegisterData(response);
                     this.licenseFile.saveLicenseFile();
                     this.checkLicenseStatus();
                     return response;
@@ -263,16 +266,16 @@ class License {
                 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]);
+                    this.currentLicenseData.updateCheckData(response);
+                    this.currentLicenseData.updateFloatingPeriod(this.currentLicenseData.license.borrowed_until || null);
+                    for (const featureName in this.currentLicenseData.features) {
+                        this.syncFeatureConsumption(this.currentLicenseData.features[featureName]);
                     }
-                    if (this.licenseFile.licenseDataCache.license.license_type == 'consumption') {
+                    if (this.currentLicenseData.license.license_type == 'consumption') {
                         this.syncConsumption();
                     }
-                    if (this.licenseFile.licenseDataCache.isGracePeriodStarted) {
-                        this.licenseFile.licenseDataCache.gracePeriodStartDate = (0, dayjs_1.default)('2099-01-01').utc().toISOString();
+                    if (this.currentLicenseData.isGracePeriodStarted) {
+                        this.currentLicenseData.gracePeriodStartDate = (0, dayjs_1.default)('2099-01-01').utc().toISOString();
                     }
                     this.licenseFile.saveLicenseFile();
                     this.checkLicenseStatus();
@@ -280,7 +283,7 @@ class License {
                 }
             }
             catch (error) {
-                if (this.licenseFile.licenseDataCache.isFloatingLicense || this.licenseFile.licenseDataCache.isActiveFloatingCloud) {
+                if (this.currentLicenseData.isFloatingLicense || this.currentLicenseData.isActiveFloatingCloud) {
                     return null;
                 }
                 throw error;
@@ -290,29 +293,29 @@ class License {
     getLicenseIDPayload() {
         var _a;
         const payload = {
-            license_id: this.licenseFile.licenseDataCache.license.id,
-            product: this.licenseFile.licenseDataCache.productCode,
-            hardware_id: this.licenseFile.licenseDataCache.hardwareID,
+            license_id: this.currentLicenseData.license.id,
+            product: this.currentLicenseData.productCode,
+            hardware_id: this.currentLicenseData.hardwareID,
         };
-        if (this.licenseFile.licenseDataCache.bundleCode) {
-            payload.bundle_code = this.licenseFile.licenseDataCache.bundleCode;
+        if (this.currentLicenseData.bundleCode) {
+            payload.bundle_code = this.currentLicenseData.bundleCode;
         }
-        if (this.licenseFile.licenseDataCache.license.license_key) {
-            payload.license_key = this.licenseFile.licenseDataCache.license.license_key;
+        if (this.currentLicenseData.license.license_key) {
+            payload.license_key = this.currentLicenseData.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;
+        if ((_a = this.currentLicenseData.license.user) === null || _a === void 0 ? void 0 : _a.email) {
+            payload.username = this.currentLicenseData.license.user.email;
         }
         return payload;
     }
     getDeactivationCode(initializationCode) {
-        return this.licenseAPI.getAirGapActivationCode(initializationCode, this.licenseFile.licenseDataCache.license.license_key);
+        return this.licenseAPI.getAirGapActivationCode(initializationCode, this.currentLicenseData.license.license_key);
     }
     deactivateAirGap(confirmationCode) {
-        if (!this.licenseAPI.verifyConfirmationCode(confirmationCode, this.licenseFile.licenseDataCache.license.license_key, this.licenseFile.licenseDataCache.policyId)) {
+        if (!this.licenseAPI.verifyConfirmationCode(confirmationCode, this.currentLicenseData.license.license_key, this.currentLicenseData.policyId)) {
             throw { status: 400, code: 'air_gap_activation_error', message: 'Error verifying airgap code' };
         }
-        this.licenseFile.licenseDataCache.deactivate();
+        this.currentLicenseData.deactivate();
         this.licenseFile.clearStorage();
     }
     deactivate() {
@@ -324,7 +327,7 @@ class License {
                 return false;
             }
             if (this.isControlledByFloatingServer) {
-                return yield this.floatingAPI.unregisterUser(undefined, this.licenseFile.licenseDataCache.license.id, this.licenseFile.licenseDataCache.productCode);
+                return yield this.floatingAPI.unregisterUser(undefined, this.currentLicenseData.license.id, this.currentLicenseData.productCode);
             }
             const payload = this.getLicenseIDPayload();
             yield this.licenseAPI.deactivateLicense(payload);
@@ -332,16 +335,16 @@ class License {
                 this.licenseFile.deleteLicenseFile();
                 return true;
             }
-            this.licenseFile.licenseDataCache.deactivate();
+            this.currentLicenseData.deactivate();
             this.licenseFile.saveLicenseFile();
         });
     }
     localCheck() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.licenseAPI.getHardwareID() != this.licenseFile.licenseDataCache.hardwareID) {
+            if (this.licenseAPI.getHardwareID() != this.currentLicenseData.hardwareID) {
                 throw { status: 500, code: 'hardware_id_mismatch', message: 'License file does not belong to this device' };
             }
-            if (this.productCode != this.licenseFile.licenseDataCache.productCode) {
+            if (this.productCode != this.currentLicenseData.productCode) {
                 throw { status: 500, code: 'product_mismatch', message: 'License file does not belong to this product' };
             }
             this.checkLicenseStatus();
@@ -357,10 +360,10 @@ class License {
     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) {
+            if ((_a = this.currentLicenseData.license.user) === null || _a === void 0 ? void 0 : _a.email) {
                 this.checkLicenseStatus();
                 return yield this.licenseAPI.changePassword({
-                    username: this.licenseFile.licenseDataCache.license.user.email,
+                    username: this.currentLicenseData.license.user.email,
                     password: oldPassword,
                     new_password: newPassword,
                 });
@@ -368,21 +371,21 @@ class License {
         });
     }
     addLocalConsumption(consumptions = 1) {
-        this.licenseFile.licenseDataCache.updateConsumption(consumptions);
+        this.currentLicenseData.updateConsumption(consumptions);
     }
     addLocalFeatureConsumption(featureCode, consumptions = 1) {
-        this.licenseFile.licenseDataCache.updateFeatureConsumption(featureCode, consumptions);
+        this.currentLicenseData.updateFeatureConsumption(featureCode, consumptions);
     }
     syncFeatureConsumption(feature) {
         return __awaiter(this, void 0, void 0, function* () {
-            const storedFeature = this.licenseFile.licenseDataCache.features[feature.code];
+            const storedFeature = this.currentLicenseData.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);
+                    response = yield this.floatingAPI.addFeatureConsumption(feature.code, storedFeature.local_consumption, this.currentLicenseData.license.id, this.currentLicenseData.productCode);
                 }
                 else {
                     const payload = this.getLicenseIDPayload();
@@ -390,9 +393,9 @@ class License {
                     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.currentLicenseData.updateFeatureData(response, feature.code);
+                if (this.currentLicenseData.isGracePeriodStarted) {
+                    this.currentLicenseData.gracePeriodStartDate = (0, dayjs_1.default)('2099-01-01').utc().toISOString();
                 }
                 this.licenseFile.saveLicenseFile();
             }
@@ -409,10 +412,10 @@ class License {
     }
     syncConsumption() {
         return __awaiter(this, arguments, void 0, function* (overages = -1) {
-            if (this.licenseFile.licenseDataCache.localConsumptions == null) {
+            if (this.currentLicenseData.localConsumptions == null) {
                 return false;
             }
-            if (this.licenseFile.licenseDataCache.localConsumptions == 0 && overages < 0) {
+            if (this.currentLicenseData.localConsumptions == 0 && overages < 0) {
                 return false;
             }
             const maxOverages = overages >= 0 ? overages : null;
@@ -420,18 +423,18 @@ class License {
             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);
+                    response = yield this.floatingAPI.addConsumption(this.currentLicenseData.localConsumptions, this.currentLicenseData.license.id, maxOverages, allowOverages, this.currentLicenseData.productCode);
                 }
                 else {
                     const payload = this.getLicenseIDPayload();
-                    payload.consumptions = this.licenseFile.licenseDataCache.localConsumptions;
+                    payload.consumptions = this.currentLicenseData.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.currentLicenseData.updateLocalConsumptionsData(response);
+                if (this.currentLicenseData.isGracePeriodStarted) {
+                    this.currentLicenseData.gracePeriodStartDate = (0, dayjs_1.default)('2099-01-01').utc().toISOString();
                 }
                 this.licenseFile.saveLicenseFile();
             }
@@ -447,20 +450,20 @@ class License {
         });
     }
     get isGracePeriod() {
-        if (!this.licenseFile.licenseDataCache.gracePeriod) {
+        if (!this.currentLicenseData.gracePeriod) {
             return false;
         }
-        this.licenseFile.licenseDataCache.updateGracePeriodStartDate();
-        return (0, dayjs_1.default)(this.licenseFile.licenseDataCache.gracePeriodEndDate).utc().isAfter((0, dayjs_1.default)().utc());
+        this.currentLicenseData.updateGracePeriodStartDate();
+        return (0, dayjs_1.default)(this.currentLicenseData.gracePeriodEndDate).utc().isAfter((0, dayjs_1.default)().utc());
     }
     floatingBorrow(borrowUntil, password) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.licenseFile.licenseDataCache.isFloatingLicense) {
+            if (this.currentLicenseData.isFloatingLicense) {
                 return false;
             }
             let response;
             if (this.isControlledByFloatingServer) {
-                response = yield this.floatingAPI.borrow(borrowUntil, this.licenseFile.licenseDataCache.license.id, this.licenseFile.licenseDataCache.productCode);
+                response = yield this.floatingAPI.borrow(borrowUntil, this.currentLicenseData.license.id, this.currentLicenseData.productCode);
             }
             else {
                 const payload = this.getLicenseIDPayload();
@@ -470,27 +473,27 @@ class License {
                 }
                 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.currentLicenseData.license.is_borrowed = true;
+            this.currentLicenseData.updateResponseData(response);
+            this.currentLicenseData.updateFloatingPeriod(this.currentLicenseData.license.borrowed_until);
             this.licenseFile.saveLicenseFile();
             return true;
         });
     }
     floatingRelease() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.licenseFile.licenseDataCache.isFloatingLicense) {
+            if (this.currentLicenseData.isFloatingLicense) {
                 return false;
             }
             this.checkLicenseStatus();
             if (this.isControlledByFloatingServer) {
-                yield this.floatingAPI.unregisterUser(undefined, this.licenseFile.licenseDataCache.license.id, this.licenseFile.licenseDataCache.productCode);
+                yield this.floatingAPI.unregisterUser(undefined, this.currentLicenseData.license.id, this.currentLicenseData.productCode);
             }
             else {
                 const payload = this.getLicenseIDPayload();
                 yield this.licenseAPI.floatingRelease(payload);
             }
-            this.licenseFile.licenseDataCache.releaseLicense();
+            this.currentLicenseData.releaseLicense();
             this.licenseFile.saveLicenseFile();
             return true;
         });
@@ -499,55 +502,55 @@ class License {
         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);
+                response = yield this.floatingAPI.registerFeature(featureCode, this.currentLicenseData.license.id, this.currentLicenseData.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.currentLicenseData.registerFeature(featureCode);
+            this.currentLicenseData.updateFeatureData(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);
+                yield this.floatingAPI.featureRelease(featureCode, this.currentLicenseData.license.id, this.currentLicenseData.productCode);
             }
             else {
                 const payload = this.getLicenseIDPayload();
                 payload.feature = featureCode;
                 yield this.licenseAPI.featureRelease(payload);
             }
-            this.licenseFile.licenseDataCache.releaseFeature(featureCode);
+            this.currentLicenseData.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) {
+        if (decodedData.hardware_id != this.currentLicenseData.hardwareID) {
             throw { status: 500, code: 'hardware_id_mismatch', message: 'License file does not belong to this device' };
         }
-        if (decodedData.product_details.short_code != this.licenseFile.licenseDataCache.productCode) {
+        if (decodedData.product_details.short_code != this.currentLicenseData.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();
+        if (resetConsumption && this.currentLicenseData.license.license_type == 'consumption') {
+            this.currentLicenseData.resetLocalConsumption();
         }
-        this.licenseFile.licenseDataCache.updateCache('update_license_offline', decodedData);
+        this.currentLicenseData.updateResponseData(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 }));
+            this.currentLicenseData.deactivate();
+            yield this.licenseAPI.deactivateOffline(Object.assign(Object.assign({}, this.currentLicenseData.getIdentificator()), { product: this.productCode, hardware_id: this.currentLicenseData.hardwareID, license_id: this.currentLicenseData.license.id }));
             const offlineData = new offline_activation_1.default();
             offlineData.isActivation = false;
-            offlineData.data = response;
+            offlineData.data = undefined;
             this.licenseFile.createRequestFile(offlineData, offlinePath);
         });
     }
@@ -559,18 +562,18 @@ class License {
                 include_custom_fields: includeCustomFields,
                 include_expired_features: includeExpiredFeatures,
             });
-            this.licenseFile.licenseDataCache.updateCache('product_details', response);
+            this.currentLicenseData.updateResponseData({ product_details: response });
             this.licenseFile.saveLicenseFile();
             return response;
         });
     }
     get productDetailsLocal() {
-        return this.licenseFile.licenseDataCache.license.product_details;
+        return this.currentLicenseData.license.product_details;
     }
     setDeviceVariablesLocal(variables, save = true) {
-        this.licenseFile.licenseDataCache.variables = [];
+        this.currentLicenseData.variables = [];
         for (const key in variables) {
-            this.licenseFile.licenseDataCache.variables.push({ variable: key, value: String(variables[key]) });
+            this.currentLicenseData.variables.push({ variable: key, value: String(variables[key]) });
         }
         if (save) {
             this.licenseFile.saveLicenseFile();
@@ -580,11 +583,11 @@ class License {
         return __awaiter(this, arguments, void 0, function* (save = false) {
             try {
                 const variables = {};
-                if (!this.licenseFile.licenseDataCache.variables.length) {
+                if (!this.currentLicenseData.variables.length) {
                     return false;
                 }
-                this.licenseFile.licenseDataCache.variables.map(item => { variables[item.variable] = item.value; });
-                yield 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 }));
+                this.currentLicenseData.variables.map(item => { variables[item.variable] = item.value; });
+                yield this.licenseAPI.trackDeviceVariables(Object.assign(Object.assign({}, this.currentLicenseData.getIdentificator()), { product: this.productCode, hardware_id: this.currentLicenseData.hardwareID, license_id: this.currentLicenseData.license.id, variables }));
                 if (save) {
                     this.licenseFile.saveLicenseFile();
                 }
@@ -598,16 +601,16 @@ class License {
         });
     }
     getDeviceVariableLocal(variable) {
-        return (this.licenseFile.licenseDataCache.variables.filter(item => item.variable == variable) || [])[0];
+        return (this.currentLicenseData.variables.filter(item => item.variable == variable) || [])[0];
     }
     getDeviceVariablesLocal() {
-        return this.licenseFile.licenseDataCache.variables;
+        return this.currentLicenseData.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);
+                const response = yield this.licenseAPI.getDeviceVariables(Object.assign(Object.assign({}, this.currentLicenseData.getIdentificator()), { product: this.productCode, hardware_id: this.currentLicenseData.hardwareID, license_id: this.currentLicenseData.license.id }));
+                this.currentLicenseData.updateResponseData({ variables: response });
                 this.licenseFile.saveLicenseFile();
             }
             catch (e) {
@@ -622,8 +625,8 @@ class License {
         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());
+        this.currentLicenseData.updateGracePeriodStartDate();
+        return (0, dayjs_1.default)(this.currentLicenseData.gracePeriodEndDate).utc().isAfter((0, dayjs_1.default)().utc());
     }
 }
 exports.default = License;