Source: portlet/portlet_util.es.js

/**
 * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by the Free
 * Software Foundation; either version 2.1 of the License, or (at your option)
 * any later version.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 * details.
 */
// Constants for URL generation
const AJAX_ACTION_VALUE = '0';
const CACHE_LEVEL_KEY = 'p_p_cacheability';
const HUB_ACTION_KEY = 'p_p_hub';
const PARTIAL_ACTION_VALUE = '1';
const PORTLET_MODE_KEY = 'p_p_mode';
const PUBLIC_RENDER_PARAM_KEY = 'p_r_p_';
const RENDER_PARAM_KEY = 'priv_r_p_';
const RESOURCE_ID_KEY = 'p_p_resource_id';
const TOKEN_DELIM = '&';
const VALUE_ARRAY_EMPTY = '';
const VALUE_DELIM = '=';
const VALUE_NULL = '';
const WINDOW_STATE_KEY = 'p_p_state';
/**
 * Compares two parameters and returns a boolean indicating if they're equal
 * or not.
 * @param {?Array.<string>} parameter1 The first parameter to compare.
 * @param {?Array.<string>} parameter2 The second parameter to compare.
 * @return {boolean}
 * @review
 */
const isParameterEqual = function (parameter1, parameter2) {
	let result = false;
	// The values are either string arrays or undefined.
	if (parameter1 === undefined && parameter2 === undefined) {
		result = true;
	}
	if (parameter1 === undefined || parameter2 === undefined) {
		result = false;
	}
	if (parameter1.length !== parameter2.length) {
		result = false;
	}
	for (let i = parameter1.length - 1; i >= 0; i--) {
		if (parameter1[i] !== parameter2[i]) {
			result = false;
		}
	}
	return result;
};
/**
 * Returns true if input state differs from the current page state.
 * Throws exception if input state is malformed.
 * @param {Object} pageRenderState The (current) page render state.
 * @param {RenderState} newState The new state to be set.
 * @param {string} portletId The portlet ID.
 * @return {boolean}  True if the two state are different.
 * @review
 */
const stateChanged = function (pageRenderState, newState, portletId) {
	let result = false;
	if (pageRenderState && pageRenderState.portlets) {
		const portletData = pageRenderState.portlets[portletId];
		if (portletData) {
			const oldState = pageRenderState.portlets[portletId].state;
			if (
				!newState.portletMode ||
				!newState.windowState ||
				!newState.parameters
			) {
				throw new Error(`Error decoding state: ${newState}`);
			}
			if (
				newState.porletMode !== oldState.portletMode ||
				newState.windowState !== oldState.windowState
			) {
				result = true;
			}
			else {
				// Has a parameter changed or been added?
				const newKeys = Object.keys(newState.parameters);
				newKeys.forEach((key) => {
					const newParameter = newState.parameters[key];
					const oldParameter = oldState.parameters[key];
					if (!isParameterEqual(newParameter, oldParameter)) {
						result = true;
					}
				});
				// Make sure no parameter was deleted
				const oldKeys = Object.keys(oldState.parameters);
				oldKeys.forEach((key) => {
					if (!newState.parameters[key]) {
						result = true;
					}
				});
			}
		}
	}
	return result;
};
/**
 * Decodes the update strings.
 * The update string is a JSON object containing the entire page state.
 * This decoder returns an object containing the portlet data for portlets whose
 * state has changed as compared to the current page state.
 * @param {Object} pageRenderState The page render state.
 * @param {string} updateString The update string to decode.
 * @return {Object}
 * @review
 */
const decodeUpdateString = function (pageRenderState, updateString) {
	const portlets =
		pageRenderState && pageRenderState.portlets
			? pageRenderState.portlets
			: {};
	try {
		const newRenderState = JSON.parse(updateString);
		if (newRenderState.portlets) {
			const keys = Object.keys(portlets);
			keys.forEach((key) => {
				const newState = newRenderState.portlets[key].state;
				const oldState = portlets[key].state;
				if (!newState || !oldState) {
					throw new Error(
						`Invalid update string.\nold state=${oldState}\nnew state=${newState}`
					);
				}
				if (stateChanged(pageRenderState, newState, key)) {
					portlets[key] = newRenderState.portlets[key];
				}
			});
		}
	}
	catch (e) {
		// Do nothing
	}
	return portlets;
};
/**
 * Function to extract data from form and encode
 * it as an 'application/x-www-form-urlencoded' string.
 * @param {string} portletId The portlet ID.
 * @param {HTMLFormElement} form Form to be submitted.
 * @review
 */
const encodeFormAsString = function (portletId, form) {
	const parameters = [];
	for (let i = 0; i < form.elements.length; i++) {
		const element = form.elements[i];
		const name = element.name;
		const tag = element.nodeName.toUpperCase();
		const type = tag === 'INPUT' ? element.type.toUpperCase() : '';
		const value = element.value;
		if (name && !element.disabled && type !== 'FILE') {
			if (tag === 'SELECT' && element.multiple) {
				const options = [...element.options];
				options.forEach((opt) => {
					if (opt.checked) {
						const value = opt.value;
						const parameter =
							encodeURIComponent(portletId + name) +
							'=' +
							encodeURIComponent(value);
						parameters.push(parameter);
					}
				});
			}
			else if (
				(type !== 'CHECKBOX' && type !== 'RADIO') ||
				element.checked
			) {
				const param =
					encodeURIComponent(portletId + name) +
					'=' +
					encodeURIComponent(value);
				parameters.push(param);
			}
		}
	}
	return parameters.join('&');
};
/**
 * Helper for encoding a multi valued parameter.
 * @param {string} name The parameter's name.
 * @param {Array.<string>} values The parameter's value.
 * @return {string}
 * @review
 */
const encodeParameter = function (name, values) {
	let str = '';
	if (Array.isArray(values)) {
		if (values.length === 0) {
			str +=
				TOKEN_DELIM +
				encodeURIComponent(name) +
				VALUE_DELIM +
				VALUE_ARRAY_EMPTY;
		}
		else {
			values.forEach((value) => {
				str += TOKEN_DELIM + encodeURIComponent(name);
				if (value === null) {
					str += VALUE_DELIM + VALUE_NULL;
				}
				else {
					str += VALUE_DELIM + encodeURIComponent(value);
				}
			});
		}
	}
	return str;
};
/**
 * Generates the required options for an action URL request
 * according to the portletId, action URL and optional form element.
 *
 * @param {string} portletId The id of the portlet.
 * @param {string} url The action url.
 * @param {HTMLFormElement} The form element.
 * @return {Object}
 * @review
 */
const generateActionUrl = function (portletId, url, form) {
	const request = {
		credentials: 'same-origin',
		method: 'POST',
		url,
	};
	if (form) {
		const enctype = form.enctype;
		if (enctype === 'multipart/form-data') {
			const formData = new FormData(form);
			request.body = formData;
		}
		else {
			const formAsString = encodeFormAsString(portletId, form);
			const method = form.method ? form.method.toUpperCase() : 'GET';
			if (method === 'GET') {
				if (url.indexOf('?') >= 0) {
					url += `&${formAsString}`;
				}
				else {
					url += `?${formAsString}`;
				}
				request.url = url;
			}
			else {
				request.body = formAsString;
				request.headers = {
					'Content-Type': 'application/x-www-form-urlencoded',
				};
			}
		}
	}
	return request;
};
/**
 * Helper for generating parameter strings for the URL
 * @param {Object} pageRenderState The page render state.
 * @param {string} portletId The portlet ID.
 * @param {string} name The parameter's name.
 * @param {string} type The parameter's type.
 * @param {string} group The parameter's group.
 * @review
 */
const generateParameterString = function (
	pageRenderState,
	portletId,
	name,
	type,
	group
) {
	let str = '';
	if (pageRenderState.portlets && pageRenderState.portlets[portletId]) {
		const portletData = pageRenderState.portlets[portletId];
		if (portletData && portletData.state && portletData.state.parameters) {
			const values = portletData.state.parameters[name];
			if (values !== undefined) {
				// If values are present, encode the mutlivalued parameter string
				if (type === PUBLIC_RENDER_PARAM_KEY) {
					str += encodeParameter(group, values);
				}
				else if (type === RENDER_PARAM_KEY) {
					str += encodeParameter(
						portletId + RENDER_PARAM_KEY + name,
						values
					);
				}
				else {
					str += encodeParameter(portletId + name, values);
				}
			}
		}
	}
	return str;
};
/**
 * Helper for generating portlet mode & window state strings for the URL.
 * @param {Object} pageRenderState The page render state.
 * @param {string} portletId The portlet ID.
 * @return {string}
 * @review
 */
const generatePortletModeAndWindowStateString = function (
	pageRenderState,
	portletId
) {
	let str = '';
	if (pageRenderState.portlets) {
		const portletData = pageRenderState.portlets[portletId];
		if (portletData.state) {
			const state = portletData.state;
			str +=
				TOKEN_DELIM +
				PORTLET_MODE_KEY +
				VALUE_DELIM +
				encodeURIComponent(state.portletMode);
			str +=
				TOKEN_DELIM +
				WINDOW_STATE_KEY +
				VALUE_DELIM +
				encodeURIComponent(state.windowState);
		}
	}
	return str;
};
/**
 * Compares the values of the named parameter in the new render state
 * with the values of that parameter in the current state.
 * @param {Object} pageRenderState The page render state.
 * @param {string} portletId The portlet ID.
 * @param {RenderState} state The new render state.
 * @param {string} name The name of the parameter to check.
 * @return {boolean} True if the new parameter's value is different from the current value.
 * @review
 */
const isParameterInStateEqual = function (
	pageRenderState,
	portletId,
	state,
	name
) {
	let result = false;
	if (pageRenderState && pageRenderState.portlets) {
		const portletData = pageRenderState.portlets[portletId];
		if (state.parameters[name] && portletData.state.parameters[name]) {
			const newParameter = state.parameters[name];
			const oldParameter = portletData.state.parameters[name];
			result = isParameterEqual(newParameter, oldParameter);
		}
	}
	return result;
};
/**
 * Gets the updated public parameters for the given portlet ID and new render state.
 * Returns an object whose properties are the group indexes of the
 * updated public parameters. The values are the new public parameter values.
 * @param {Object} pageRenderState The page render state.
 * @param {string} portletId The portlet ID.
 * @param {RenderState} state The new render state.
 * @return {Object} Object containing the updated public render parameters.
 * @review
 */
const getUpdatedPublicRenderParameters = function (
	pageRenderState,
	portletId,
	state
) {
	const publicRenderParameters = {};
	if (pageRenderState && pageRenderState.portlets) {
		const portletData = pageRenderState.portlets[portletId];
		if (portletData && portletData.pubParms) {
			const portletPublicParameters = portletData.pubParms;
			const keys = Object.keys(portletPublicParameters);
			keys.forEach((key) => {
				if (
					!isParameterInStateEqual(
						pageRenderState,
						portletId,
						state,
						key
					)
				) {
					const group = portletPublicParameters[key];
					publicRenderParameters[group] = state.parameters[key];
				}
			});
		}
	}
	return publicRenderParameters;
};
/**
 * Function for checking if a parameter is public.
 * @param {Object} pageRenderState The page render state.
 * @param {string} portletId  The portlet ID.
 * @param {string} name  The name of the parameter to check.
 * @return {boolean}
 * @review
 */
const isPublicParameter = function (pageRenderState, portletId, name) {
	let result = false;
	if (pageRenderState && pageRenderState.portlets) {
		const portletData = pageRenderState.portlets[portletId];
		if (portletData && portletData.pubParms) {
			const keys = Object.keys(portletData.pubParms);
			result = keys.includes(name);
		}
	}
	return result;
};
/**
 * Returns a URL of the specified type.
 * @param {Object} pageRenderState The page render state.
 * @param {string} type The URL type.
 * @param {string} portletId The portlet ID.
 * @param {Object} parameters Additional parameters. May be <code>null</code>.
 * @param {string} cache Cacheability. Must be present if type = "RESOURCE". May be <code>null</code>.
 * @param {string} resourceId Resource ID. May be present if type = "RESOURCE". May be <code>null</code>.
 * @return {Promise} A promise that resolves the generated URL.
 * @review
 */
const getUrl = function (
	pageRenderState,
	type,
	portletId,
	parameters,
	cache,
	resourceId
) {
	let cacheability = 'cacheLevelPage';
	let str = '';
	let url = '';
	if (pageRenderState && pageRenderState.portlets) {
		// If target portlet not defined for render URL, set it to null
		if (type === 'RENDER' && portletId === undefined) {
			portletId = null;
		}
		const portletData = pageRenderState.portlets[portletId];
		if (portletData) {
			if (type === 'RESOURCE') {
				url = decodeURIComponent(portletData.encodedResourceURL);
				if (cache) {
					cacheability = cache;
				}
				url +=
					TOKEN_DELIM +
					CACHE_LEVEL_KEY +
					VALUE_DELIM +
					encodeURIComponent(cacheability);
				if (resourceId) {
					url +=
						TOKEN_DELIM +
						RESOURCE_ID_KEY +
						VALUE_DELIM +
						encodeURIComponent(resourceId);
				}
			}
			else if (type === 'RENDER' && portletId !== null) {
				url = decodeURIComponent(portletData.encodedRenderURL);
			}
			else if (type === 'RENDER') {
				url = decodeURIComponent(pageRenderState.encodedCurrentURL);
			}
			else if (type === 'ACTION') {
				url = decodeURIComponent(portletData.encodedActionURL);
				url +=
					TOKEN_DELIM +
					HUB_ACTION_KEY +
					VALUE_DELIM +
					encodeURIComponent(AJAX_ACTION_VALUE);
			}
			else if (type === 'PARTIAL_ACTION') {
				url = decodeURIComponent(portletData.encodedActionURL);
				url +=
					TOKEN_DELIM +
					HUB_ACTION_KEY +
					VALUE_DELIM +
					encodeURIComponent(PARTIAL_ACTION_VALUE);
			}
			// Now add the state to the URL, taking into account cacheability if
			// we're dealing with a resource URL.
			// Put the private & public parameters on the URL if cacheability != FULL
			if (type !== 'RESOURCE' || cacheability !== 'cacheLevelFull') {
				// Add the state for the target portlet, if there is one.
				// (for the render URL, pid can be null, and the state will have
				// been added previously)
				if (portletId) {
					url += generatePortletModeAndWindowStateString(
						pageRenderState,
						portletId
					);
				}
				// Add the state for the target portlet, if there is one.
				// (for the render URL, pid can be null, and the state will have
				// been added previously)
				if (portletId) {
					str = '';
					if (portletData.state && portletData.state.parameters) {
						const stateParameters = portletData.state.parameters;
						const keys = Object.keys(stateParameters);
						keys.forEach((key) => {
							if (
								!isPublicParameter(
									pageRenderState,
									portletId,
									key
								)
							) {
								str += generateParameterString(
									pageRenderState,
									portletId,
									key,
									RENDER_PARAM_KEY
								);
							}
						});
						url += str;
					}
				}
				// Add the public render parameters for all portlets
				if (pageRenderState.prpMap) {
					str = '';
					const publicRenderParameters = {};
					const mapKeys = Object.keys(pageRenderState.prpMap);
					mapKeys.forEach((mapKey) => {
						const groupKeys = Object.keys(
							pageRenderState.prpMap[mapKey]
						);
						groupKeys.forEach((groupKey) => {
							const groupName =
								pageRenderState.prpMap[mapKey][groupKey];
							const parts = groupName.split('|');
							// Only need to add parameter once, since it is shared
							if (
								!Object.hasOwnProperty.call(
									publicRenderParameters,
									mapKey
								)
							) {
								publicRenderParameters[
									mapKey
								] = generateParameterString(
									pageRenderState,
									parts[0],
									parts[1],
									PUBLIC_RENDER_PARAM_KEY,
									mapKey
								);
								str += publicRenderParameters[mapKey];
							}
						});
					});
					url += str;
				}
			}
		}
	}
	// Encode resource or action parameters
	if (parameters) {
		str = '';
		const parameterKeys = Object.keys(parameters);
		parameterKeys.forEach((parameterKey) => {
			str += encodeParameter(
				portletId + parameterKey,
				parameters[parameterKey]
			);
		});
		url += str;
	}
	return Promise.resolve(url);
};
/**
 * Used by the portlet hub methods to check the number and types of the
 * arguments.
 *
 * @param {string[]} args The argument list to be checked.
 * @param {number} min The minimum number of arguments.
 * @param {number} max The maximum number of arguments. If this value is
 * undefined, the function can take any number of arguments greater
 * than max.
 * @param {string[]} types An array containing the expected parameter types in the
 * order of occurrance in the argument array.
 * @throws {TypeError} Thrown if the parameters are in some manner incorrect.
 * @review
 */
const validateArguments = function (args = [], min = 0, max = 1, types = []) {
	if (args.length < min) {
		throw new TypeError(
			`Too few arguments provided: Number of arguments: ${args.length}`
		);
	}
	else if (args.length > max) {
		throw new TypeError(
			`Too many arguments provided: ${[].join.call(args, ', ')}`
		);
	}
	else if (Array.isArray(types)) {
		let i = Math.min(args.length, types.length) - 1;
		for (i; i >= 0; i--) {
			if (typeof args[i] !== types[i]) {
				throw new TypeError(
					`Parameter ${i} is of type ${typeof args[
						i
					]} rather than the expected type ${types[i]}`
				);
			}
			if (args[i] === null || args[i] === undefined) {
				throw new TypeError(`Argument is ${typeof args[i]}`);
			}
		}
	}
};
/**
 * Validates an HTMLFormElement
 * @param {?HTMLFormElement} form The form element to be validated.
 * @throws {TypeError} Thrown if the form is not an HTMLFormElement.
 * @throws {TypeError} Thrown if the form's method attribute is not valid.
 * @throws {TypeError} Thrown if the form's enctype attribute is not valid.
 * @throws {TypeError} Thrown if the form's enctype attribute is not valid.
 * @review
 */
const validateForm = function (form) {
	if (!(form instanceof HTMLFormElement)) {
		throw new TypeError('Element must be an HTMLFormElement');
	}
	const method = form.method ? form.method.toUpperCase() : undefined;
	if (method && method !== 'GET' && method !== 'POST') {
		throw new TypeError(
			`Invalid form method ${method}. Allowed methods are GET & POST`
		);
	}
	const enctype = form.enctype;
	if (
		enctype &&
		enctype !== 'application/x-www-form-urlencoded' &&
		enctype !== 'multipart/form-data'
	) {
		throw new TypeError(
			`Invalid form enctype ${enctype}. Allowed: 'application/x-www-form-urlencoded' & 'multipart/form-data'`
		);
	}
	if (enctype && enctype === 'multipart/form-data' && method !== 'POST') {
		throw new TypeError(
			'Invalid method with multipart/form-data. Must be POST'
		);
	}
	if (!enctype || enctype === 'application/x-www-form-urlencoded') {
		const l = form.elements.length;
		for (let i = 0; i < l; i++) {
			if (
				form.elements[i].nodeName.toUpperCase() === 'INPUT' &&
				form.elements[i].type.toUpperCase() === 'FILE'
			) {
				throw new TypeError(
					"Must use enctype = 'multipart/form-data' with input type FILE."
				);
			}
		}
	}
};
/**
 * Verifies that the input parameters are in valid format.
 *
 * Parameters must be an object containing parameter names. It may also
 * contain no property names which represents the case of having no
 * parameters.
 *
 * If properties are present, each property must refer to an array of string
 * values. The array length must be at least 1, because each parameter must
 * have a value. However, a value of 'null' may appear in any array entry.
 *
 * To represent a <code>null</code> value, the property value must equal [null].
 *
 * @param {Object} parameters The parameters to check.
 * @throws {TypeError} Thrown if the parameters are incorrect.
 * @review
 */
const validateParameters = function (parameters) {
	if (!(parameters !== undefined && parameters !== null)) {
		throw new TypeError(`The parameter object is: ${typeof parameters}`);
	}
	const keys = Object.keys(parameters);
	keys.forEach((key) => {
		if (!Array.isArray(parameters[key])) {
			throw new TypeError(`${key} parameter is not an array`);
		}
		if (!parameters[key].length) {
			throw new TypeError(`${key} parameter is an empty array`);
		}
	});
};
/**
 * Validates the specificed portletId against the list
 * of current portlet in the pageRenderState.
 *
 * @param {string} portletId The ID of the portlet to be registered.
 * @param {Object} pageRenderState The current pageRenderState.
 * @return {boolean} A flag indicating if the specified portlet id is valid.
 * @review
 */
const validatePortletId = function (pageRenderState = {}, portletId = '') {
	return (
		pageRenderState.portlets &&
		Object.keys(pageRenderState.portlets).includes(portletId)
	);
};
/**
 * Verifies that the input parameters are in valid format, that the portlet
 * mode and window state values are allowed for the portlet.
 * @param {RenderState} state The render state object to check.
 * @param {Object} portletData The porltet render state.
 * @throws {TypeError} Thrown if any component of the state is incorrect.
 * @review
 */
const validateState = function (state = {}, portletData = {}) {
	validateParameters(state.parameters);
	const portletMode = state.portletMode;
	if (typeof portletMode !== 'string') {
		throw new TypeError(
			`Invalid parameters. portletMode is ${typeof portletMode}`
		);
	}
	else {
		const allowedPortletModes = portletData.allowedPM;
		if (!allowedPortletModes.includes(portletMode.toLowerCase())) {
			throw new TypeError(
				`Invalid portletMode=${portletMode} is not in ${allowedPortletModes}`
			);
		}
	}
	const windowState = state.windowState;
	if (typeof windowState !== 'string') {
		throw new TypeError(
			`Invalid parameters. windowState is ${typeof windowState}`
		);
	}
	else {
		const allowedWindowStates = portletData.allowedWS;
		if (!allowedWindowStates.includes(windowState.toLowerCase())) {
			throw new TypeError(
				`Invalid windowState=${windowState} is not in ${allowedWindowStates}`
			);
		}
	}
};
export {
	decodeUpdateString,
	encodeFormAsString,
	generateActionUrl,
	generatePortletModeAndWindowStateString,
	getUpdatedPublicRenderParameters,
	getUrl,
	validateArguments,
	validateForm,
	validateParameters,
	validatePortletId,
	validateState,
};