openecomp-ui/src/nfvo-utils/Validator.js

/*!
 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */

import * as ValidatorJS from 'validator';
import i18n from 'nfvo-utils/i18n/i18n.js';

class Validator {
	static get globalValidationFunctions() {
		return {
			required: value => {
				return typeof value === 'string' ? value.replace(/\s+/g, '') !== '' : value !== '';
			},
			requiredChooseOption: value => value !== '',
			maxLength: (value, length) => ValidatorJS.isLength(value, {max: length}),
			minLength: (value, length) => ValidatorJS.isLength(value, {min: length}),
			pattern: (value, pattern) => ValidatorJS.matches(value, pattern),
			numeric: value => {
				if (value === '') {
					// to allow empty value which is not zero
					return true;
				}
				return ValidatorJS.isNumeric(value);
			},
			maximum: (value, maxValue) => {return (value === undefined) ? true : (value <= maxValue);},
			minimum: (value, minValue) => {return (value === undefined) ? true : (value >= minValue);},
			maximumExclusive: (value, maxValue) => {return (value === undefined) ? true : (value < maxValue);},
			minimumExclusive: (value, minValue) => {return (value === undefined) ? true : (value > minValue);},
			alphanumeric: value => ValidatorJS.isAlphanumeric(value),
			alphanumericWithSpaces: value => ValidatorJS.isAlphanumeric(value.replace(/ /g, '')),
			validateName: value => ValidatorJS.isAlphanumeric(value.replace(/\s|\.|\_|\-/g, ''), 'en-US'),
			validateVendorName: value => ValidatorJS.isAlphanumeric(value.replace(/[\x7F-\xFF]|\s/g, ''), 'en-US'),
			freeEnglishText: value => ValidatorJS.isAlphanumeric(value.replace(/\s|\.|\_|\-|\,|\(|\)|\?/g, ''), 'en-US'),
			email: value => ValidatorJS.isEmail(value),
			ip: value => ValidatorJS.isIP(value),
			url: value => ValidatorJS.isURL(value),
			alphanumericWithUnderscores: value => ValidatorJS.isAlphanumeric(value.replace(/_/g, '')),
			requiredChoiceWithOther: (value, otherValue) => {
				let chosen = value.choice;
				// if we have an empty multiple select we have a problem since it's required
				let validationFunc = this.globalValidationFunctions['required'];
				if (value.choices) {
					if (value.choices.length === 0) {
						return  false;
					} else {
						// continuing validation with the first chosen value in case we have the 'Other' field
						chosen = value.choices[0];
					}
				}
				if (chosen !== otherValue) {
					return validationFunc(chosen, true);
				} else { // when 'Other' was chosen, validate other value
					return validationFunc(value.other, true);
				}
			}
		};
	}

	static get globalValidationMessagingFunctions() {
		return {
			required: () => i18n('Field is required'),
			requiredChooseOption: () => i18n('Field should have one of these options'),
			requiredChoiceWithOther: () => i18n('Field is required'),
			maxLength: (value, maxLength) => i18n('Field value has exceeded it\'s limit, {maxLength}. current length: {length}', {
				length: value.length,
				maxLength
			}),
			minLength: (value, minLength) => i18n('Field value should contain at least {minLength} characters.', {minLength: minLength}),
			pattern: (value, pattern) => i18n('Field value should match the pattern: {pattern}.', {pattern: pattern}),
			numeric: () => i18n('Field value should contain numbers only.'),
			maximum: (value, maxValue) => i18n('Field value should be less or equal to: {maxValue}.', {maxValue: maxValue}),
			minimum: (value, minValue) => i18n('Field value should be at least: {minValue}.', {minValue: minValue.toString()}),
			maximumExclusive: (value, maxValue) => i18n('Field value should be less than: {maxValue}.', {maxValue: maxValue}),
			minimumExclusive: (value, minValue) => i18n('Field value should be more than: {minValue}.', {minValue: minValue.toString()}),
			alphanumeric: () => i18n('Field value should contain letters or digits only.'),
			alphanumericWithSpaces: () => i18n('Field value should contain letters, digits or spaces only.'),
			validateName: ()=> i18n('Field value should contain English letters, digits , spaces, underscores, dashes and dots only.'),
			validateVendorName: ()=> i18n('Field value should contain English letters digits and spaces only.'),
			freeEnglishText: ()=> i18n('Field value should contain  English letters, digits , spaces, underscores, dashes and dots only.'),
			email: () => i18n('Field value should be a valid email address.'),
			ip: () => i18n('Field value should be a valid ip address.'),
			url: () => i18n('Field value should be a valid url address.'),
			general: () => i18n('Field value is invalid.'),
			alphanumericWithUnderscores: () => i18n('Field value should contain letters, digits or _ only.')
		};
	}

	static validateItem(value, data, type) {
		let validationFunc = this.globalValidationFunctions[type];
		const isValid = validationFunc(value, data);
		let errorText = '';
		if (!isValid) {
			errorText = this.globalValidationMessagingFunctions[type](value, data);
		}
		return {
			isValid,
			errorText
		};
	}

	static validate(fieldName, value, validations, state, customValidations) {
		let result = { isValid: true, errorText: '' };
		for (let validation of validations) {
			result = this.validateItem(value, validation.data, validation.type);
			if (!result.isValid) {
				return result;
			}
		}
		if (customValidations) {
			let validationFunc = customValidations[fieldName];
			if (validationFunc) {
				result = validationFunc(value, state);
			}
		}
		return result;
	}

	static isItemNameAlreadyExistsInList({itemId, itemName, list}) {
		itemName = itemName.toLowerCase();
		return list[itemName] && list[itemName] !== itemId;
	}
}

export default Validator;