License API changelog

Fixed a bug with incorrectly calculated overages for consumptions

Added product_details object to device_licenses endpoint response

Implemented transactionalized license/bundle activation and consumption actions

Implemented installation_file_id logic in order webhook

Improved validation schema for order webhook

Fixed an issue with check_license containing installation file values from older installation files

Integrated improved checks for activation and consumption limits

Fixed an error on user_licenses endpoint that occured when the optional product parameter was provided

Validation hotfix for boolean query parameters written in non-lowercase

Performance improvements across API

Stricter schema validation across API

Fixed partial activation of bundle licenses on online and offline bundle activation endpoints

Error message when creating license device fails

Offline signature in offline activation response for OAuth payloads

Implemented OAuth functionality

Fixed `is_initial_password` not being updated on password change

Implemented `activate_bundle_offline` endpoint

Implemented `env` parameter in `check_license` and `product_details` endpoints

Implemented `offline_floating_consumptions_sync` event in `add_consumption` and `add_feature_consumption` endpoints

Implemented a check for `allow_negative_consumptions` during license deactivation: negative consumption value will not be applied during deactivation if the license does not support negative consumptions

Fixed `customer_account_id` logic to ensure provided customer and customer_account values are consistent if they already exist in db

Fixed signature header in `sso_url` to calculate the signature of the entire payload and not just the url string

Improved validation error messages to return expected request payload schema

Integrated customer account association for orders using `customer_account_id` and `add_to_customer_account` in order webhook

Fixed missing user fields in license responses

Fixed an error in the add_consumption endpoint

Implemented keycloak integration in all API endpoints

Optimized license webhook key generation

Implemented `products` endpoint

Implemented `device_licenses` endpoint

Implemented `activate_bundle` endpoint

`product` parameter made optional in `user_licenses` endpoint

Implemented SSO authentication on `get user licenses` endpoint

Fixed incorrect error message in `get user licenses` endpoint when authentication data is correct but user is not assigned to requested product

Fixed handling customer ID in order create webhook

Added missing `allow_negative_consumptions` property to feature consumption endpoint

Fixed a bug in order creation where customer.id could be manually overriden in the request data

Fixed a bug where trial_days field was missing in license activation response for licenses with enabled trial

Fixed a bug where allow_negative_consumptions field was missing on consumption license response

Expanded validation for order create endpoint to ensure top-level product is a bundle and fields specific to key/user-based licenses can only be sent with the appropriate license type

Fixed a bug where floating slots could be reserved with an expired license

Fixed a bug where a license with multiple activations and no device transfers could only be activated once

Fixed a bug where negative feature consumptions could be sent for a license where feature consumptions did not allow negative values

Implemented support for consumption notifications when consumption amount passes thresholds defined by notification policies

Implemented the alphabet parameter in the key generator which allows specifying which characters are used to generate license keys

Added trial notifications for trial licenses during order creation

Implemented support for negative consumptions and license policies allowing negative consumptions

Reworked device count to avoid problems with devices being incorrectly enumerated after license reset

Improved calculating total activations, consumptions and transfers to avoid a concurrency bug when a large number of concurrent requests occured on the same license

Fixed a bug where license keys were being generated on user-based licenses

Fixed a bug where floating borrow was allowed using expired licenses

Expanded order creation endpoint to allow for more flexible parameter overriding and setting initial values when creating bundle orders

Added check for allowed license types when creating bundle orders

Fixed filtering by licenseID for bundle orders

Fixed incorrect password validation in user_licenses endpoint

Fixed a bug in request validation schema

Added `user_licenses` endpoint to return a list of licenses for a given user

Added `license_id` parameter as an optional filter to all endpoints that work with licenses

Fixed a bug in request validation schema

Added `validity_period` attribute to license policies

Fixed a bug that would fetch the incorrect license when activating/deactivating user-based bundle licenses without a provided bundle code

Fixed a bug causing duplicate IDs during order creation in the order webhook

Fixed an error message being returned while activating trial license for user-based licenses

Added support for optional `policy_code` parameter to order webhook

Added support for device variables in activation payloads for activate_license and activate_offline endpoints

Added optional `key_length` parameter to license webhook to allow for increased license key length

Improved key generator by increasing cap for maximum number of keys generated per request to 10.000

Fixed a bug where a user with multiple user-based bundle licenses could not activate the correct license

Restored the missing `address` field in license customer info

Added support for `licensepring-hardware-key` in offline license payloads

Added optional `include_metadata_string` parameter to endpoints to return `metadata` values as serialized JSON strings in `metadata_string`

Added `is_air_gapped` field to license activation and check response

Added support for `licensespring-hardware-key` header

Fixed sending `max_consumption` to license feature consumption analytics

Added `trial_days` to license response on check_license if license is in trial

Added support for `enabled` field on create_order logic

Added `bundle_code` for user based bundle licenses

Added license events for Events API

Add `disabled_product` and `archived_product` to the list of errors

Expanded customer Events API data

Added support for `customer.updated` event

Improved date header verification

Metadata can be set both as a JSON string literal and JSON object format.

Metadata returned inside offline activation response

Added support for `webhooks`

Added `include_expired_feature` to `check_license` endpoint

Fixed activating user based product bundle licenses

Added `include_latest_version` and `include_custom_fields` to `product_details` endpoint

Implemented floating cloud license features

Remove `extra` field from analytics activity

Using `integrations` table to support Stripe integration

Fixed saving anayltics data when `trial_key` request fails

Fixed parsing `os_ver` and `mac_address` query params

Deployment improvements

Fixed keygen timeouts on large number of concurrent keygen requests

Return error message on order create if `license users` contains a higher number of users than `max_license_users` allow

Fixed `customer_license_users` endpoint and `product` query param filter

Ignore `validity_period` if perpetual and consumption type licenses are not in trial

Optimization to the deployment process

Fixed logger invocation when activating an expired trial license

Use fallback when default license policy not assigned

Added fallback in unlikely case that a product does not have a default license policy

Fixed `validity_period` response on activated licenses

Added `validity_period` check on all trial licenses

`metadata` is returned inside `product_details` object when doing license check and activation

Update internal sentry handler

Added metadata JSON field on customers, orders, licenses, products and product features

Implemented `pm2` process management tool

Optimized license fetching SQL query

Replaced Express with Fastify

Updated all internal libraries to the latest version

All api methods rewritten from callbacks to async/await syntax

max_activations on /trial_key endpoint changed so that it is inherited from license policy with 1 as a default

Fixed customer_does_not_exist error format

fix: When creating customer api will trim emails and remove whitespaces

Docs for new Mgmt API endpoint

Added grace_period and allow_grace_period to licenses and license policy

Extended License api/shared keys - multiple api/shared keys per account, allowed products option, labels, read_only and revoked fields.

Handle failed attempt when creating subscriptions using Stripe checkout

Expand expiration check with grace_period

Support for adhoc intervalUnit

Expand extra field on AnalyticsActivity model to send additional details in JSON

Added allow_unlimited_activations and allow_unlimited_consumptions to the data model

Added Date header validation

always return device_id on license activation response as Integer

Order webhook returns new order_items in response

always return device_id on license activation response as Integer

Order webhook returns new order_items in response

times_activated value on a License cannot be set lower than 0 on license deactivation

Added min validation on times_activated field on the License model

Allowed Authorization code grant for SSO

Sending LicenseSignature header on license check and activation

Attaching license_signature_v2 to offline activation response object

Consumptions events use max_consumptions field instead of max_overages to send events

Expanded consumptions events inside Usage Report with additional data

Added Max consumptions reached and Max feature consumptions reached Usage report events

Support for sending license_policy code when creating ordeobject

Attached user object tot the offline activation response

License deactivation decrements total_activations field on license user

Added new custom attribute is_single_license

Implemented max_activations on license users

Restrict setting invalid license type values

Implement feature consumption analytics activity

Restrict setting invalid license type values

Implement feature consumption analytics activity

license check and activation response expanded with can_borrow and max_borrow_time

floating/borrow endpoint sets the device as floating_in_use if slots available improvement: Support for product bundles on all endpoints

Add borrowed_until field to license check response and clear the borrowed_until device field on floating release

/floating/release endpoint changes borrowed_until on device to null

Fix borrow_until field in floating_borrow endpoint

Add is_borrowed field to the the license check

Fix creating duplicate license devices on batch license activation requests with unique license_id+hwid constraint

Send notification request on license activation

Added api/v4/floating/borrow endpoint and floating_borrow analytics activity event

Expand floating watchdog to handle license borrowing

Fixed 2checkout error handler when wrong product code is sent

Extend data model to enable license borrowing

Fixed sso error format

Added new /get_device_variables endpoint

Analytics activity expanded with single_sign_on and get_device_variables events

Fixed max_transfers logic

Fixed trial_key analytics action

Handle prevent device transfer value on max_transfers

Accept Single Sign On id_token and customer_account_code params on license_activation endpoint

Created SSO authentication method

Added new api/v4/sso_url for generating AWS Cognito Single Sign On url for enabled customer accounts

Added SSO id_token validation method

Enable sending customer with id only when creating order

Return start_date field in license response on license check and license activation requests

Add start_date on the License model and return error if license activation attempted before this date

Extend trial_key endpoint with optional license_policy query param and assign first_name, last_name and phone_number to the license user if available

Replace deprecated requests library

fastspring: Fix timeout with related offe

stripe: Support license_policy price attribute ( enable using custom_fields and product_features )

Expand company settings with allow_offline_floating_cloud

Prevent floating_cloud licenses to be activated offline

Deprecated order and license webhooks

Added allow_trial and trial_days fields to license template

FastSpring: Update max_activations along floating_users on subscription update when floating_users_from_quantity attribute is present

Add CustomerAccount to the model and return customer_account if available

Append total_consumptions when deactivating offlin

Added is_initial_password and phone_number to the user object on license check and activation

Added JSON validation on track_device_variables endpoint

Return error on trial_key if product does not allow trial

Expand installation file on license check

Use true email inside user object on license check

Return overages with product features on license check and activation

Fastspring: Expand subscription.updated event logic to handle changing custom fields, product features and adding new licenses to the order

License API extended with license policiesr

Floating slots check removed from license activation

fastspring: Fix subscription.updated handler when floating_users_from_quantity attribute

fastspring: Add assign_customer_as_user attribute

stripe: Add is_license_manager attribute

Fixed Order classMethod

Offline deactivation file expanded to support license and license features consumptions update

Added channel field to installation_file and expanded /installation_file endpoint with remaining fields

Removed license_user_id from the Device

stripe: Fixed customer.subscription.updated and customer.subscription.deleted events

Added channel field to installation_file and expanded /installation_file endpoint with remaining fields

Removed license_user_id from the Device

stripe: Fixed customer.subscription.updated and customer.subscription.deleted events

Created ping endpoint

Implemented license_user_id to the Device

Created ping endpoint

Implemented license_user_id to the Device

Added license_user_id to Device

Stripe: Fixed subscription renewals

Added new analytics actions and expanded with status code

Expand check_license response with is_floating field

Add initial_password to the trial_key response and fix assignUser method

Fastspring: Add is_license_manager custom attribute to set customer as manager

Fix transfer_count logic and implement max_transfers

Fix generating signature on license_check response (use ISO string format)

Created customer_license_users endpoint to list all license_users on all orders on some customer

Added signature to license_check response

Expand /installation_file and /versions endpoint responses with release_date field, add env query param and return only versions and files with release date less than maintenance_period or validity_period of the license

Add requires_version field on installation files

Add overages and consumption resets on product features

stripe: Fixed checking for a subscription id

Create order_users endpoint to list all license_users on some order

Fix installation_file fields on license_check response

Fix sending emails on user/manager assign

stripe: Fix setting subscription as trial - use trial_end and trial_start fields

Include order_store_id to license check response

Save event data from integrations ( FastSpring, Stripe ) to LicenseHistory data field

Fix License activation usage report when source is sdk

Create initial password for new users on trial licenses

stripe: Add assign_customer_as_user custom attribute

stripe: Expand Stripe integration to receive trialing status and to respond on customer.subscription.updated event (# 24047525)

Added floating_in_use_devices in license check response

Fastspring: Implemented subscription.updated event handling for single licenses

Added license_key in check_license response

Fastspring: Added custom attribute floating_users_from_quantity

Attach device id to the updated license device on activation to fix missing device id bug

Expand license activation response with license_key and product_details

Send order reference when creating an order

Fix getting installation files for user based products

Implement license floating timeout value

Add consumption fields to offline activation response if license is consumption type

fastspring: Added support for trial subscriptions

fastspring: Added support for setting custom fields on licenses

Implemented transfer_count on licenses and add new DeviceActivationHistory table

Check license validity_period on license_activation

Stripe: Get products from the database

Fixed verification of user based offline license signature

Added new LicenseHistory events: License activated, License deactivated, Consumption added, Feature consumption added, Floating release, Offline license activated, Offline license deactivated

use StripeEvent table to check for duplicate Stripe event

added optional allow_overages and max_overages request query params to add_consumption endpoint

Stripe: implemented v1 of stripe LicenseSpring integration

Implement time-limited product features using expiry_date field

Prevent creating duplicate customers when using getTrialLicense webhook with same email address

Prevent creating duplicate product features on order create

subscriptions: log SQL query when prolonging license

Fastspring: support for creating floating cloud licenses using custom attribute floating_cloud (int)

Fastspring: fix setting validity_period on subscription prolong - event type subscription.charge.completed fix: properly set max_overages as unlimited when 0 is sent as a value

send consumption_period and reset_consumption fields inside license activation and license check response payload

Add requestID to newRelic attributes

Fix failing LicenseHistory in check

timeout on invalid call to webhook/license

intermittent issues with webhook/order

fastspring contextual - subscription.deactivated fix

implemented support for duration in weeks (fastspring contextual and in general))

updated Licenses model with note property and using it in v4 post order on item for license db storage.

extended existing snowflake algorithm with magic number randomness.

api/v4/versions returns only enabled versions.

api/v4/activate_license and api/v4/check_license for user-based license returns user object with email, first_name and last_name properties

offline_activation additional headers saved to license device (app_ver, sdk_ver, ip_local, ...) license_activation and license_check - in case user has more then one license, using not the first but the last one from the database for activation / checkOrder

api/v4/change_password user_email API parameter renamed to password and old_password API parameter to password

api/v4/change_password implemented

intermittent issues with webhook/order

fastspring contextual - subscription.deactivated fix

implemented support for duration in weeks (fastspring contextual and in general))

updated Licenses model with note property and using it in v4 post order on item for license db storage.

extended existing snowflake algorithm with magic number randomness.

api/v4/versions returns only enabled versions.

api/v4/activate_license and api/v4/check_license for user-based license returns user object with email, first_name and last_name properties

offline_activation additional headers saved to license device (app_ver, sdk_ver, ip_local, ...) license_activation and license_check - in case user has more then one license, using not the first but the last one from the database for activation / checkOrder

api/v4/change_password user_email API parameter renamed to password and old_password API parameter to password

api/v4/change_password implemented

support for floating on-prem in /webhook/order

fix issue with assigning user licenses in /webhook/order

allow setting maintenance_period on webhook/order

date is not a required header element on authorization (to support electron.js)

Fixed license type on trial_key API. Previously the trial_key API was issuing trial keys that were perpetual. It now uses the default license type for which the product was configured.

New error message: license_key_exists error when webhook/order receives an order with an existing license key

Fixed consumption features assignment on webhook/order

Fixed assignment of trial_days on trial_key API. It was previously defaulting to 30 day trial duration on perpetual licenses. Trial keys are now issued with the default trial duration as configured with the product.

Added the ability to set the value of custom_fields on webhook/order

Changed value of the custom field value to be a TEXT

Fixed trial key validity period when set explicitly through webhook/order

Fixed times_activated on activate_license API

API added max_consumptions to response of api/v4/add_feature_consumption

API webhook: fixes to 2checkout key generation

API webhook/order - user-based licenses now assign users

Implemented overages

Added allow_overages, max_overages, reset_consumption and consumption_period to product and license UI

API webhook/order - support for consumption overages implemented

API max_overages and allow_overages implemented into v4/add_consumption

API sending max_consumption(s) on add_feature_consumption and add_consumption endpointss

API added times_activated and max_activations on check_license and activate_license endpoints

BUG on API: fix license_custom_field API response