@fontoxml/fontoxml-development-tools/src/FdtLicense.js

'use strict';

const fs = require('fs');
const os = require('os');
const path = require('path');
const util = require('util');

const readFile = util.promisify(fs.readFile);
const writeFile = util.promisify(fs.writeFile);

const getParentDirectoryContainingFileSync = require('./getParentDirectoryContainingFileSync');

const DEFAULT_LICENSE_FILENAME = 'fonto.lic';

const MINIMUM_LICENSE_VERSION = 1.0;

const LICENSE_FILE_ERROR_SOLUTION = 'Please check if you have a license file installed, or contact support for obtaining a license file.';

class FdtLicense {
	constructor (app) {
		this.app = app;

		this._backendBaseUrl = process.env.LICENSE_SERVICE_URL || 'https://licenseserver.fontoxml.com';

		this._license = this._loadLicenseFile();
	}

	/**
	 * Determine the license file path.
	 *
	 * @return {string|null}
	 */
	_getLicenseFilename () {
		if (process.env.FDT_LICENSE_FILENAME) {
			return process.env.FDT_LICENSE_FILENAME;
		}

		const licenseFilenameInHomedir = path.join(os.homedir(), DEFAULT_LICENSE_FILENAME);
		const licenseFilenameInPathAncestry = getParentDirectoryContainingFileSync(process.cwd(), DEFAULT_LICENSE_FILENAME, true);

		if (licenseFilenameInPathAncestry) {
			return path.join(licenseFilenameInPathAncestry, DEFAULT_LICENSE_FILENAME);
		}

		try {
			fs.accessSync(licenseFilenameInHomedir, fs.constants.R_OK);
			return licenseFilenameInHomedir;
		}
		catch (_error) {
			// Do nothing
		}

		return null;
	}

	_decodeAndValidateLicenseFileData (data) {
		let decryptedData;

		try {
			decryptedData = JSON.parse(Buffer.from(data, 'base64').toString('utf8'));
		}
		catch (_error) {
			return { error: new this.app.cli.InputError('License file has invalid data.', LICENSE_FILE_ERROR_SOLUTION) };
		}

		if (typeof decryptedData !== 'object') {
			return { error: new this.app.cli.InputError('License file has invalid data.', LICENSE_FILE_ERROR_SOLUTION) };
		}

		// key
		if (!decryptedData.key || typeof decryptedData.key !== 'string') {
			return { error: new this.app.cli.InputError('License file has an invalid key.', LICENSE_FILE_ERROR_SOLUTION) };
		}

		// licensee
		if (!decryptedData.licensee || typeof decryptedData.licensee !== 'string') {
			return { error: new this.app.cli.InputError('License file has an invalid licensee.', LICENSE_FILE_ERROR_SOLUTION) };
		}

		// products
		if (!decryptedData.products || !Array.isArray(decryptedData.products)) {
			return { error: new this.app.cli.InputError('License file has invalid products.', LICENSE_FILE_ERROR_SOLUTION) };
		}

		const hasInvalidProducts = decryptedData.products.some(product => {
			return typeof product !== 'object' ||
				!product.id || typeof product.id !== 'string' ||
				!product.label || typeof product.label !== 'string';
		});
		if (hasInvalidProducts) {
			return { error: new this.app.cli.InputError('License file has invalid products.', LICENSE_FILE_ERROR_SOLUTION) };
		}

		// version
		if (typeof decryptedData.version !== 'number') {
			return { error: new this.app.cli.InputError('License file has an invalid version.', LICENSE_FILE_ERROR_SOLUTION) };
		}

		if (decryptedData.version < MINIMUM_LICENSE_VERSION) {
			return { error: new this.app.cli.InputError(`The license file version is too old for this version of ${this.app.getInfo().name}.`, `Please upgrade your license by running '${this.app.getInfo().name} license validate'.`) };
		}

		if (decryptedData.version >= Math.floor(MINIMUM_LICENSE_VERSION) + 1) {
			return { error: new this.app.cli.InputError(`The license file version is too new for this version of ${this.app.getInfo().name}.`, `Please upgrade ${this.app.getInfo().name}.`) };
		}

		return {
			data: decryptedData
		};
	}

	/**
	 * Load the local license file from disk and parse it.
	 *
	 * @return {Object} The license load data.
	 */
	_loadLicenseFile () {
		const filename = this._getLicenseFilename();
		if (!filename) {
			return {
				error: new this.app.cli.InputError(
					'The required license file could not be found.',
					LICENSE_FILE_ERROR_SOLUTION)
			};
		}

		let data;
		try {
			data = fs.readFileSync(filename, 'utf8');
		}
		catch (_error) {
			return {
				error: new this.app.cli.InputError(
					'The required license file could not be read.',
					LICENSE_FILE_ERROR_SOLUTION)
			};
		}

		const validationResult = this._decodeAndValidateLicenseFileData(data);

		if (validationResult.data) {
			validationResult.filename = filename;
		}

		return validationResult;
	}

	/**
	 * Get all (public) license information.
	 *
	 * @return {Object|null}
	 * @return {string}        .licensee
	 * @return {Array<Object>} .products
	 */
	getLicenseInfo () {
		if (!this._license.data) {
			return null;
		}

		return {
			licensee: this._license.data.licensee,
			products: this._license.data.products.map(product => Object.assign({}, product)),
			version: this._license.data.version
		};
	}

	/**
	 * Get a buffer for the license file.
	 *
	 * @return {Promise<Buffer>}
	 */
	getLicenseFileBuffer () {
		this.ensureLicenseFileExists();
		return readFile(this._license.filename)
			.catch(() => {
				throw new Error('Could not read the license file.');
			});
	}

	/**
	 * Check if specific product licenses are present. This does not validate remotely.
	 *
	 * Set .setRequiresLicenseValidation() on your command first, if you need to make sure the
	 * license is up to date.
	 *
	 * @param {Array<string>} productIds
	 *
	 * @return {boolean}
	 */
	hasProductLicenses (productIds) {
		if (!this._license.data) {
			return false;
		}

		return productIds.every(productId => {
			return this._license.data.products.find(product => product.id === productId);
		});
	}

	/**
	 * Check if there is a license file.
	 *
	 * @return {boolean} Returns true if there is a license file, throws otherwise.
	 */
	ensureLicenseFileExists () {
		if (!this._license.data) {
			throw this._license.error;
		}

		return true;
	}

	/**
	 * Ensure the user has the specified products licenses by checking the license file.
	 *
	 * Validate the license with .validateAndUpdateLicenseFile() first if you need to make sure the
	 * license is up to date.
	 *
	 * @param {Array<string>} productIds
	 *
	 * @return {boolean} Returns true if the user has the specified products licenses, throws otherwise.
	 */
	ensureProductLicenses (productIds) {
		this.ensureLicenseFileExists();

		const missingProductIds = productIds.filter(productId => {
			return !this._license.data.products.find(product => product.id === productId);
		});

		if (missingProductIds.length) {
			throw new this.app.cli.InputError(
				`You appear to be missing one of the required product licenses (${missingProductIds.join(', ')}).`,
				`Check if your license is valid and have the required product licenses by running '${this.app.getInfo().name} license validate', and afterwards try to run the current command again.`);
		}

		return true;
	}

	/**
	 * Validate the license by checking for validity online. This will also update the local license
	 * file in case the license is changed remotely.
	 *
	 * @return {Promise<boolean>}
	 */
	validateAndUpdateLicenseFile () {
		return this.getLicenseFileBuffer()
			.then(licenseFileBuffer => {
				const requestPromise = require('request-promise-native');
				// Remotely validate the license file.
				return requestPromise.post(this._backendBaseUrl + '/license/validate', {
					formData: {
						license: {
							value: licenseFileBuffer,
							options: {
								filename: DEFAULT_LICENSE_FILENAME,
								contentType: 'application/octet-stream'
							}
						}
					},
					resolveWithFullResponse: true,
					simple: false
				});
			})
			.catch(error => {
				if (error.hasOwnProperty('solution')) {
					throw error;
				}

				throw new Error(`Could not get response from license server. Please check if you have a working internet connection.`);
			})
			.then(response => {
				switch (response.statusCode) {
					case 200: {
						// Validate response before writing to disk.
						const validationResult = this._decodeAndValidateLicenseFileData(response.body);
						if (validationResult.error) {
							throw new Error('Invalid updated license data received while checking license.');
						}

						// Update license file on disk.
						return writeFile(this._license.filename, response.body)
							.catch(_error => {
								throw new Error('Could not update local license file.');
							})
							.then(() => {
								// Update license file in memory.
								this._license = this._loadLicenseFile();

								if (!this._license.data) {
									throw this._license.error;
								}

								return true;
							});
					}
					case 204:
						return true;
					case 400: {
						const error = new Error(`License is invalid. Run '${this.app.getInfo().name} license validate' to check your license.`);
						error.statusCode = response.statusCode;
						throw error;
					}
					case 401:
					case 403: {
						const error = new Error(`License is not valid (anymore). Run '${this.app.getInfo().name} license validate' to check your license.`);
						error.statusCode = response.statusCode;
						throw error;
					}
					default: {
						const error = new Error(`Error while checking license (${response.statusCode}).`);
						error.statusCode = response.statusCode;
						throw error;
					}
				}
			});
	}

	/**
	 * Get data for a specific product(s). This can be, for example, credentials for specific systems or urls for specific systems.
	 *
	 * @param {Object} productsWithData
	 * @param {Object} productsWithData.<productId>
	 *
	 * @return {Promise<Object>} An Object containing the data for the products, in the same format as the request, but filled with response values instead of request values.
	 */
	getDataForProducts (productsWithData) {
		return this.getLicenseFileBuffer()
			.then(licenseFileBuffer => {
				const requestPromise = require('request-promise-native');
				// Remotely get the required data.
				return requestPromise.post(this._backendBaseUrl + '/product/data', {
					formData: {
						request: {
							value: JSON.stringify({
								products: productsWithData
							}),
							options: {
								contentType: 'application/json'
							}
						},
						license: {
							value: licenseFileBuffer,
							options: {
								filename: DEFAULT_LICENSE_FILENAME,
								contentType: 'application/octet-stream'
							}
						}
					},
					resolveWithFullResponse: true,
					simple: false
				});
			})
			.catch(error => {
				if (error.hasOwnProperty('solution')) {
					throw error;
				}

				throw new Error(`Could not get response from license server. Please check if you have a working internet connection.`);
			})
			.then(response => {
				switch (response.statusCode) {
					case 200: {
						let data;
						try {
							data = JSON.parse(response.body);
						}
						catch (_error) {
							throw new Error('Invalid response data while getting data for products.');
						}
						return data;
					}
					case 400: {
						const error = new Error(`License is invalid. Run '${this.app.getInfo().name} license validate' to check your license.`);
						error.statusCode = response.statusCode;
						throw error;
					}
					case 401:
					case 403: {
						const error = new Error(`License is not valid (anymore). Run '${this.app.getInfo().name} license validate' to check your license.`);
						error.statusCode = response.statusCode;
						throw error;
					}
					case 404: {
						const error = new Error('Could not get requested data, because one or more of the requested products or their data does not exist.');
						error.statusCode = response.statusCode;
						throw error;
					}
					default: {
						const error = new Error(`Error while getting data for products (${response.statusCode}).`);
						error.statusCode = response.statusCode;
						throw error;
					}
				}
			});
	}
}

module.exports = FdtLicense;