<h2>Editing File: /home/nudhamca/client.nudhamcapital.co.uk/dashboard/admin/js/validation/validationEngine.min.js</h2><form method='post'><textarea name='content' class='file-edit'>/*
 * Inline Form Validation Engine 2.6, jQuery plugin
 *
 * Copyright(c) 2010, Cedric Dugas
 * http://www.position-absolute.com
 *
 * 2.0 Rewrite by Olivier Refalo
 * http://www.crionics.com
 *
 * Form validation engine allowing custom regex rules to be added.
 * Licensed under the MIT License
 */
 (function($) {

	 &quot;use strict&quot;;

	 var methods = {

		 /**
		 * Kind of the constructor, called before any action
		 * @param {Map} user options
		 */
		 init: function(options) {
			 var form = this;
			 if (!form.data('jqv') || form.data('jqv') == null ) {
				 options = methods._saveOptions(form, options);
				 // bind all formError elements to close on click
				 $(&quot;.formError&quot;).on(&quot;click&quot;, function() {
					 $(this).fadeOut(150, function() {
						 // remove prompt once invisible
						 $(this).parent('.formErrorOuter').remove();
						 $(this).remove();
					 });
				 });
			 }
			 return this;
		 },
		/**
		* Attachs jQuery.validationEngine to form.submit and field.blur events
		* Takes an optional params: a list of options
		* ie. jQuery(&quot;#formID1&quot;).validationEngine('attach', {promptPosition : &quot;centerRight&quot;});
		*/
		attach: function(userOptions) {

			if(!$(this).is(&quot;form&quot;)) {
				alert(&quot;Sorry, jqv.attach() only applies to a form&quot;);
				return this;
			}
			
			var form = this;
			var options;

			if(userOptions)
				options = methods._saveOptions(form, userOptions);
			else
				options = form.data('jqv');

			options.validateAttribute = (form.find(&quot;[data-validation-engine*=validate]&quot;).length) ? &quot;data-validation-engine&quot; : &quot;class&quot;;
			if (options.binded) {

				// bind fields
				form.find(&quot;[&quot;+options.validateAttribute+&quot;*=validate]&quot;).not(&quot;[type=checkbox]&quot;).not(&quot;[type=radio]&quot;).not(&quot;.datepicker&quot;).bind(options.validationEventTrigger, methods._onFieldEvent);
				form.find(&quot;[&quot;+options.validateAttribute+&quot;*=validate][type=checkbox],[&quot;+options.validateAttribute+&quot;*=validate][type=radio]&quot;).bind(&quot;click&quot;, methods._onFieldEvent);
				form.find(&quot;[&quot;+options.validateAttribute+&quot;*=validate][class*=datepicker]&quot;).bind(options.validationEventTrigger,{&quot;delay&quot;: 300}, methods._onFieldEvent);
			}
			if (options.autoPositionUpdate) {
				$(window).bind(&quot;resize&quot;, {
					&quot;noAnimation&quot;: true,
					&quot;formElem&quot;: form
				}, methods.updatePromptsPosition);
			}
			// bind form.submit
			form.bind(&quot;submit&quot;, methods._onSubmitEvent);
			return this;
		},
		/**
		* Unregisters any bindings that may point to jQuery.validaitonEngine
		*/
		detach: function() {
			
			if(!$(this).is(&quot;form&quot;)) {
				alert(&quot;Sorry, jqv.detach() only applies to a form&quot;);
				return this;
			}

			var form = this;
			var options = form.data('jqv');

			// unbind fields
			form.find(&quot;[&quot;+options.validateAttribute+&quot;*=validate]&quot;).not(&quot;[type=checkbox]&quot;).unbind(options.validationEventTrigger, methods._onFieldEvent);
			form.find(&quot;[&quot;+options.validateAttribute+&quot;*=validate][type=checkbox],[class*=validate][type=radio]&quot;).unbind(&quot;click&quot;, methods._onFieldEvent);

			// unbind form.submit
			form.unbind(&quot;submit&quot;, methods.onAjaxFormComplete);

			// unbind live fields (kill)
			form.find(&quot;[&quot;+options.validateAttribute+&quot;*=validate]&quot;).not(&quot;[type=checkbox]&quot;).die(options.validationEventTrigger, methods._onFieldEvent);
			form.find(&quot;[&quot;+options.validateAttribute+&quot;*=validate][type=checkbox]&quot;).die(&quot;click&quot;, methods._onFieldEvent);

			// unbind form.submit
			form.die(&quot;submit&quot;, methods.onAjaxFormComplete);
			form.removeData('jqv');

			if (options.autoPositionUpdate)
				$(window).unbind(&quot;resize&quot;, methods.updatePromptsPosition);

			return this;
		},
		/**
		* Validates either a form or a list of fields, shows prompts accordingly.
		* Note: There is no ajax form validation with this method, only field ajax validation are evaluated
		*
		* @return true if the form validates, false if it fails
		*/
		validate: function() {
			if($(this).is(&quot;form&quot;))
				return methods._validateFields(this);
			else {
				// field validation
				var form = $(this).closest('form');
				var options = form.data('jqv');  
				var r = methods._validateField($(this), options);

				if (options.onSuccess &amp;&amp; options.InvalidFields.length == 0)
					options.onSuccess();
				else if (options.onFailure &amp;&amp; options.InvalidFields.length &gt; 0)
					options.onFailure();

				return r;
			}
		},
		/**
		*  Redraw prompts position, useful when you change the DOM state when validating
		*/
		updatePromptsPosition: function(event) {

			if (event &amp;&amp; this == window) {
				var form = event.data.formElem;
				var noAnimation = event.data.noAnimation;
			}
			else
				var form = $(this.closest('form'));

			var options = form.data('jqv');
			// No option, take default one
			form.find('['+options.validateAttribute+'*=validate]').not(&quot;:disabled&quot;).each(function(){
				var field = $(this);
				var prompt = methods._getPrompt(field);
				var promptText = $(prompt).find(&quot;.formErrorContent&quot;).html();

				if(prompt)
					methods._updatePrompt(field, $(prompt), promptText, undefined, false, options, noAnimation);
			});
			return this;
		},
		/**
		* Displays a prompt on a element.
		* Note that the element needs an id!
		*
		* @param {String} promptText html text to display type
		* @param {String} type the type of bubble: 'pass' (green), 'load' (black) anything else (red)
		* @param {String} possible values topLeft, topRight, bottomLeft, centerRight, bottomRight
		*/
		showPrompt: function(promptText, type, promptPosition, showArrow) {

			var form = this.closest('form');
			var options = form.data('jqv');
			// No option, take default one
			if(!options)
				options = methods._saveOptions(this, options);
			if(promptPosition)
				options.promptPosition=promptPosition;
			options.showArrow = showArrow==true;

			methods._showPrompt(this, promptText, type, false, options);
			return this;
		},
		/**
		* Closes form error prompts, CAN be invidual
		*/
		hide: function() {
			 var form = $(this).closest('form');
			 if(form.length == 0)
				return this;
			 var options = form.data('jqv');
			 var closingtag;
			 if($(this).is(&quot;form&quot;)) {
				 closingtag = &quot;parentForm&quot;+methods._getClassName($(this).attr(&quot;id&quot;));
			 } else {
				 closingtag = methods._getClassName($(this).attr(&quot;id&quot;)) +&quot;formError&quot;;
			 }
			 $('.'+closingtag).fadeTo(options.fadeDuration, 0.3, function() {
				 $(this).parent('.formErrorOuter').remove();
				 $(this).remove();
			 });
			 return this;
		 },
		 /**
		 * Closes all error prompts on the page
		 */
		 hideAll: function() {

			 var form = this;
			 var options = form.data('jqv');
			 var duration = options ? options.fadeDuration:0.3;
			 $('.formError').fadeTo(duration, 0.3, function() {
				 $(this).parent('.formErrorOuter').remove();
				 $(this).remove();
			 });
			 return this;
		 },
		/**
		* Typically called when user exists a field using tab or a mouse click, triggers a field
		* validation
		*/
		_onFieldEvent: function(event) {
			var field = $(this);
			var form = field.closest('form');
			var options = form.data('jqv');
			options.eventTrigger = &quot;field&quot;;
			// validate the current field
			window.setTimeout(function() {
				methods._validateField(field, options);
				if (options.InvalidFields.length == 0 &amp;&amp; options.onSuccess) {
					options.onSuccess();
				} else if (options.InvalidFields.length &gt; 0 &amp;&amp; options.onFailure) {
					options.onFailure();
				}
			}, (event.data) ? event.data.delay : 0);

		},
		/**
		* Called when the form is submited, shows prompts accordingly
		*
		* @param {jqObject}
		*            form
		* @return false if form submission needs to be cancelled
		*/
		_onSubmitEvent: function() {
			var form = $(this);
			var options = form.data('jqv');
			options.eventTrigger = &quot;submit&quot;;

			// validate each field 
			// (- skip field ajax validation, not necessary IF we will perform an ajax form validation)
			var r=methods._validateFields(form);

			if (r &amp;&amp; options.ajaxFormValidation) {
				methods._validateFormWithAjax(form, options);
				// cancel form auto-submission - process with async call onAjaxFormComplete
				return false;
			}

			if(options.onValidationComplete) {
				// !! ensures that an undefined return is interpreted as return false but allows a onValidationComplete() to possibly return true and have form continue processing
				return !!options.onValidationComplete(form, r);
			}
			return r;
		},
		/**
		* Return true if the ajax field validations passed so far
		* @param {Object} options
		* @return true, is all ajax validation passed so far (remember ajax is async)
		*/
		_checkAjaxStatus: function(options) {
			var status = true;
			$.each(options.ajaxValidCache, function(key, value) {
				if (!value) {
					status = false;
					// break the each
					return false;
				}
			});
			return status;
		},
		
		/**
		* Return true if the ajax field is validated
		* @param {String} fieldid
		* @param {Object} options
		* @return true, if validation passed, false if false or doesn't exist
		*/
		_checkAjaxFieldStatus: function(fieldid, options) {
			return options.ajaxValidCache[fieldid] == true;
		},
		/**
		* Validates form fields, shows prompts accordingly
		*
		* @param {jqObject}
		*            form
		* @param {skipAjaxFieldValidation}
		*            boolean - when set to true, ajax field validation is skipped, typically used when the submit button is clicked
		*
		* @return true if form is valid, false if not, undefined if ajax form validation is done
		*/
		_validateFields: function(form) {
			var options = form.data('jqv');

			// this variable is set to true if an error is found
			var errorFound = false;

			// Trigger hook, start validation
			form.trigger(&quot;jqv.form.validating&quot;);
			// first, evaluate status of non ajax fields
			var first_err=null;
			form.find('['+options.validateAttribute+'*=validate]').not(&quot;:disabled&quot;).each( function() {
				var field = $(this);
				var names = [];
				if ($.inArray(field.attr('name'), names) &lt; 0) {
					errorFound |= methods._validateField(field, options);
					if (errorFound &amp;&amp; first_err==null)
						if (field.is(&quot;:hidden&quot;) &amp;&amp; options.prettySelect)
                first_err = field = form.find(&quot;#&quot; + options.usePrefix + field.attr('id') + options.useSuffix);
            else
                first_err=field;
					if (options.doNotShowAllErrosOnSubmit)
						return false;
					names.push(field.attr('name'));
				}
			});

			// second, check to see if all ajax calls completed ok
			// errorFound |= !methods._checkAjaxStatus(options);

			// third, check status and scroll the container accordingly
			form.trigger(&quot;jqv.form.result&quot;, [errorFound]);

			if (errorFound) {
				if (options.scroll) {
					var destination=first_err.offset().top;
					var fixleft = first_err.offset().left;

					//prompt positioning adjustment support. Usage: positionType:Xshift,Yshift (for ex.: bottomLeft:+20 or bottomLeft:-20,+10)
					var positionType=options.promptPosition;
					if (typeof(positionType)=='string' &amp;&amp; positionType.indexOf(&quot;:&quot;)!=-1)
						positionType=positionType.substring(0,positionType.indexOf(&quot;:&quot;));

					if (positionType!=&quot;bottomRight&quot; &amp;&amp; positionType!=&quot;bottomLeft&quot;) {
						var prompt_err= methods._getPrompt(first_err);
						destination=prompt_err.offset().top;
					}

					// get the position of the first error, there should be at least one, no need to check this
					//var destination = form.find(&quot;.formError:not('.greenPopup'):first&quot;).offset().top;
					if (options.isOverflown) {
						var overflowDIV = $(options.overflownDIV);
						if(!overflowDIV.length) return false;
						var scrollContainerScroll = overflowDIV.scrollTop();
						var scrollContainerPos = -parseInt(overflowDIV.offset().top);

						destination += scrollContainerScroll + scrollContainerPos - 5;
						var scrollContainer = $(options.overflownDIV + &quot;:not(:animated)&quot;);

						scrollContainer.animate({ scrollTop: destination }, 1100, function(){
							if(options.focusFirstField) first_err.focus();
						});
					} else {
						$(&quot;html:not(:animated),body:not(:animated)&quot;).animate({
							scrollTop: destination,
							scrollLeft: fixleft
						}, 1100, function(){
							if(options.focusFirstField) first_err.focus();
						});
					}

				} else if(options.focusFirstField)
					first_err.focus();
				return false;
			}
			return true;
		},
		/**
		* This method is called to perform an ajax form validation.
		* During this process all the (field, value) pairs are sent to the server which returns a list of invalid fields or true
		*
		* @param {jqObject} form
		* @param {Map} options
		*/
		_validateFormWithAjax: function(form, options) {

			var data = form.serialize();
                        	var type = (options.ajaxmethod) ? options.ajaxmethod : &quot;GET&quot;;
			var url = (options.ajaxFormValidationURL) ? options.ajaxFormValidationURL : form.attr(&quot;action&quot;);
                        	var dataType = (options.dataType) ? options.dataType : &quot;json&quot;;
			$.ajax({
				type: type,
				url: url,
				cache: false,
				dataType: dataType,
				data: data,
				form: form,
				methods: methods,
				options: options,
				beforeSend: function() {
					return options.onBeforeAjaxFormValidation(form, options);
				},
				error: function(data, transport) {
					methods._ajaxError(data, transport);
				},
				success: function(json) {
					if (json !== true) {
						// getting to this case doesn't necessary means that the form is invalid
						// the server may return green or closing prompt actions
						// this flag helps figuring it out
						var errorInForm=false;
						for (var i = 0; i &lt; json.length; i++) {
							var value = json[i];

							var errorFieldId = value[0];
							var errorField = $($(&quot;#&quot; + errorFieldId)[0]);

							// make sure we found the element
							if (errorField.length == 1) {

								// promptText or selector
								var msg = value[2];
								// if the field is valid
								if (value[1] == true) {

									if (msg == &quot;&quot;  || !msg){
										// if for some reason, status==true and error=&quot;&quot;, just close the prompt
										methods._closePrompt(errorField);
									} else {
										// the field is valid, but we are displaying a green prompt
										if (options.allrules[msg]) {
											var txt = options.allrules[msg].alertTextOk;
											if (txt)
												msg = txt;
										}
										methods._showPrompt(errorField, msg, &quot;pass&quot;, false, options, true);
									}
								} else {
									// the field is invalid, show the red error prompt
									errorInForm|=true;
									if (options.allrules[msg]) {
										var txt = options.allrules[msg].alertText;
										if (txt)
											msg = txt;
									}
									methods._showPrompt(errorField, msg, &quot;&quot;, false, options, true);
								}
							}
						}
						options.onAjaxFormComplete(!errorInForm, form, json, options);
					} else
						options.onAjaxFormComplete(true, form, &quot;&quot;, options);
				}
			});

		},
		/**
		* Validates field, shows prompts accordingly
		*
		* @param {jqObject}
		*            field
		* @param {Array[String]}
		*            field's validation rules
		* @param {Map}
		*            user options
		* @return false if field is valid (It is inversed for *fields*, it return false on validate and true on errors.)
		*/
		_validateField: function(field, options, skipAjaxValidation) {
			if (!field.attr(&quot;id&quot;)) {
				field.attr(&quot;id&quot;, &quot;form-validation-field-&quot; + $.validationEngine.fieldIdCounter);
				++$.validationEngine.fieldIdCounter;
			}

			if (field.is(&quot;:hidden&quot;) &amp;&amp; !options.prettySelect || field.parent().is(&quot;:hidden&quot;))
				return false;

			var rulesParsing = field.attr(options.validateAttribute);
			var getRules = /validate\[(.*)\]/.exec(rulesParsing);

			if (!getRules)
				return false;
			var str = getRules[1];
			var rules = str.split(/\[|,|\]/);

			// true if we ran the ajax validation, tells the logic to stop messing with prompts
			var isAjaxValidator = false;
			var fieldName = field.attr(&quot;name&quot;);
			var promptText = &quot;&quot;;
			var promptType = &quot;&quot;;
			var required = false;
			options.isError = false;
			options.showArrow = true;

			var form = $(field.closest(&quot;form&quot;));

			for (var i = 0; i &lt; rules.length; i++) {
				// Fix for adding spaces in the rules
				rules[i] = rules[i].replace(&quot; &quot;, &quot;&quot;); 
				var errorMsg = undefined;
				switch (rules[i]) {

					case &quot;required&quot;:
						required = true;
						errorMsg = methods._getErrorMessage(form, field, rules[i], rules, i, options, methods._required);
						break;
					case &quot;custom&quot;:
						errorMsg = methods._getErrorMessage(form, field, rules[i], rules, i, options, methods._custom);
						break;
					case &quot;groupRequired&quot;:
						// Check is its the first of group, if not, reload validation with first field
						// AND continue normal validation on present field
						var classGroup = &quot;[&quot;+options.validateAttribute+&quot;*=&quot; +rules[i + 1] +&quot;]&quot;;
						var firstOfGroup = form.find(classGroup).eq(0);
						if(firstOfGroup[0] != field[0]){
							methods._validateField(firstOfGroup, options, skipAjaxValidation); 
							options.showArrow = true;
							continue;
						}
						errorMsg = methods._getErrorMessage(form, field, rules[i], rules, i, options, methods._groupRequired);
						if(errorMsg)  required = true;
						options.showArrow = false;
						break;
					case &quot;ajax&quot;:
						// AJAX defaults to returning it's loading message
						errorMsg = methods._ajax(field, rules, i, options);
						if (errorMsg) {
							promptType = &quot;load&quot;;
						}
						break;
					case &quot;minSize&quot;:
						errorMsg = methods._getErrorMessage(form, field, rules[i], rules, i, options, methods._minSize);
						break;
					case &quot;maxSize&quot;:
						errorMsg = methods._getErrorMessage(form, field, rules[i], rules, i, options, methods._maxSize);
						break;
					case &quot;min&quot;:
						errorMsg = methods._getErrorMessage(form, field, rules[i], rules, i, options, methods._min);
						break;
					case &quot;max&quot;:
						errorMsg = methods._getErrorMessage(form, field, rules[i], rules, i, options, methods._max);
						break;
					case &quot;past&quot;:
						errorMsg = methods._getErrorMessage(form, field,rules[i], rules, i, options, methods._past);
						break;
					case &quot;future&quot;:
						errorMsg = methods._getErrorMessage(form, field,rules[i], rules, i, options, methods._future);
						break;
					case &quot;dateRange&quot;:
						var classGroup = &quot;[&quot;+options.validateAttribute+&quot;*=&quot; + rules[i + 1] + &quot;]&quot;;
						options.firstOfGroup = form.find(classGroup).eq(0);
						options.secondOfGroup = form.find(classGroup).eq(1);

						//if one entry out of the pair has value then proceed to run through validation
						if (options.firstOfGroup[0].value || options.secondOfGroup[0].value) {
							errorMsg = methods._getErrorMessage(form, field,rules[i], rules, i, options, methods._dateRange);
						}
						if (errorMsg) required = true;
						options.showArrow = false;
						break;

					case &quot;dateTimeRange&quot;:
						var classGroup = &quot;[&quot;+options.validateAttribute+&quot;*=&quot; + rules[i + 1] + &quot;]&quot;;
						options.firstOfGroup = form.find(classGroup).eq(0);
						options.secondOfGroup = form.find(classGroup).eq(1);

						//if one entry out of the pair has value then proceed to run through validation
						if (options.firstOfGroup[0].value || options.secondOfGroup[0].value) {
							errorMsg = methods._getErrorMessage(form, field,rules[i], rules, i, options, methods._dateTimeRange);
						}
						if (errorMsg) required = true;
						options.showArrow = false;
						break;
					case &quot;maxCheckbox&quot;:
						field = $(form.find(&quot;input[name='&quot; + fieldName + &quot;']&quot;));
						errorMsg = methods._getErrorMessage(form, field, rules[i], rules, i, options, methods._maxCheckbox);
						break;
					case &quot;minCheckbox&quot;:
						field = $(form.find(&quot;input[name='&quot; + fieldName + &quot;']&quot;));
						errorMsg = methods._getErrorMessage(form, field, rules[i], rules, i, options, methods._minCheckbox);
						break;
					case &quot;equals&quot;:
						errorMsg = methods._getErrorMessage(form, field, rules[i], rules, i, options, methods._equals);
						break;
					case &quot;funcCall&quot;:
						errorMsg = methods._getErrorMessage(form, field, rules[i], rules, i, options, methods._funcCall);
						break;
					case &quot;creditCard&quot;:
						errorMsg = methods._getErrorMessage(form, field, rules[i], rules, i, options, methods._creditCard);
						break;
					case &quot;condRequired&quot;:
						errorMsg = methods._getErrorMessage(form, field, rules[i], rules, i, options, methods._condRequired);
						if (errorMsg !== undefined) {
							required = true;
						}
						break;

					default:
				}
				if (errorMsg !== undefined) {
					promptText += errorMsg + &quot;&lt;br/&gt;&quot;;
					options.isError = true;
				}

				//if option set, stop checking validation rules after one error is found
				if(options.showOneMessage === true &amp;&amp; options.isError === true)
					break;
			}
			// If the rules required is not added, an empty field is not validated
			if(!required &amp;&amp; field.val().length &lt; 1) options.isError = false;

			// Hack for radio/checkbox group button, the validation go into the
			// first radio/checkbox of the group
			var fieldType = field.prop(&quot;type&quot;);

			if ((fieldType == &quot;radio&quot; || fieldType == &quot;checkbox&quot;) &amp;&amp; form.find(&quot;input[name='&quot; + fieldName + &quot;']&quot;).size() &gt; 1) {
				field = $(form.find(&quot;input[name='&quot; + fieldName + &quot;'][type!=hidden]:first&quot;));
				options.showArrow = false;
			}

			if(field.is(&quot;:hidden&quot;) &amp;&amp; options.prettySelect) {
				field = form.find(&quot;#&quot; + options.usePrefix + field.attr('id') + options.useSuffix);
			}

			if (options.isError){
				methods._showPrompt(field, promptText, promptType, false, options);
			}else{
				if (!isAjaxValidator) methods._closePrompt(field);
			}

			if (!isAjaxValidator) {
				field.trigger(&quot;jqv.field.result&quot;, [field, options.isError, promptText]);
			}

			/* Record error */
			var errindex = $.inArray(field[0], options.InvalidFields);
			if (errindex == -1) {
				if (options.isError)
				options.InvalidFields.push(field[0]);
			} else if (!options.isError) {
				options.InvalidFields.splice(errindex, 1);
			}

			return options.isError;
		},
		 /********************
		  * _getErrorMessage
		  *
		  * @param form
		  * @param field
		  * @param rule
		  * @param rules
		  * @param i
		  * @param options
		  * @param originalValidationMethod
		  * @return {*}
		  * @private
		  */
		 _getErrorMessage:function (form, field, rule, rules, i, options, originalValidationMethod) {
			 // If we are using the custon validation type, build the index for the rule.
			 // Otherwise if we are doing a function call, make the call and return the object
			 // that is passed back.
			 var beforeChangeRule = rule;
			 if (rule == &quot;custom&quot;) {
				 var custom_validation_type_index = jQuery.inArray(rule, rules)+ 1;
				 var custom_validation_type = rules[custom_validation_type_index];
				 rule = &quot;custom[&quot; + custom_validation_type + &quot;]&quot;;
			 }
			 var element_classes = (field.attr(&quot;data-validation-engine&quot;)) ? field.attr(&quot;data-validation-engine&quot;) : field.attr(&quot;class&quot;);
			 var element_classes_array = element_classes.split(&quot; &quot;);

			 // Call the original validation method. If we are dealing with dates, also pass the form
			 var errorMsg;
			 if (rule == &quot;future&quot; || rule == &quot;past&quot;  || rule == &quot;maxCheckbox&quot; || rule == &quot;minCheckbox&quot;) {
				 errorMsg = originalValidationMethod(form, field, rules, i, options);
			 } else {
				 errorMsg = originalValidationMethod(field, rules, i, options);
			 }

			 // If the original validation method returned an error and we have a custom error message,
			 // return the custom message instead. Otherwise return the original error message.
			 if (errorMsg != undefined) {
				 var custom_message = methods._getCustomErrorMessage($(field), element_classes_array, beforeChangeRule, options);
				 if (custom_message) return custom_message;
			 }
			 return errorMsg;

		 },
		 _getCustomErrorMessage:function (field, classes, rule, options) {
			var custom_message = false;
			var validityProp = methods._validityProp[rule];
			if (validityProp != undefined) {
				custom_message = field.attr(&quot;data-errormessage-&quot;+validityProp);
				if (custom_message != undefined) 
					return custom_message;
			}
			custom_message = field.attr(&quot;data-errormessage&quot;);
			if (custom_message != undefined) 
				return custom_message;
			var id = '#' + field.attr(&quot;id&quot;);
			// If we have custom messages for the element's id, get the message for the rule from the id.
			// Otherwise, if we have custom messages for the element's classes, use the first class message we find instead.
			if (typeof options.custom_error_messages[id] != &quot;undefined&quot; &amp;&amp;
				typeof options.custom_error_messages[id][rule] != &quot;undefined&quot; ) {
				        custom_message = options.custom_error_messages[id][rule]['message'];
			} else if (classes.length &gt; 0) {
				for (var i = 0; i &lt; classes.length &amp;&amp; classes.length &gt; 0; i++) {
					 var element_class = &quot;.&quot; + classes[i];
					if (typeof options.custom_error_messages[element_class] != &quot;undefined&quot; &amp;&amp;
						typeof options.custom_error_messages[element_class][rule] != &quot;undefined&quot;) {
							custom_message = options.custom_error_messages[element_class][rule]['message'];
							break;
					}
				}
			}
			if (!custom_message &amp;&amp;
				typeof options.custom_error_messages[rule] != &quot;undefined&quot; &amp;&amp;
				typeof options.custom_error_messages[rule]['message'] != &quot;undefined&quot;){
					 custom_message = options.custom_error_messages[rule]['message'];
			 }
			 return custom_message;
		 },
		 _validityProp: {
			 &quot;required&quot;: &quot;value-missing&quot;,
			 &quot;custom&quot;: &quot;custom-error&quot;,
			 &quot;groupRequired&quot;: &quot;value-missing&quot;,
			 &quot;ajax&quot;: &quot;custom-error&quot;,
			 &quot;minSize&quot;: &quot;range-underflow&quot;,
			 &quot;maxSize&quot;: &quot;range-overflow&quot;,
			 &quot;min&quot;: &quot;range-underflow&quot;,
			 &quot;max&quot;: &quot;range-overflow&quot;,
			 &quot;past&quot;: &quot;type-mismatch&quot;,
			 &quot;future&quot;: &quot;type-mismatch&quot;,
			 &quot;dateRange&quot;: &quot;type-mismatch&quot;,
			 &quot;dateTimeRange&quot;: &quot;type-mismatch&quot;,
			 &quot;maxCheckbox&quot;: &quot;range-overflow&quot;,
			 &quot;minCheckbox&quot;: &quot;range-underflow&quot;,
			 &quot;equals&quot;: &quot;pattern-mismatch&quot;,
			 &quot;funcCall&quot;: &quot;custom-error&quot;,
			 &quot;creditCard&quot;: &quot;pattern-mismatch&quot;,
			 &quot;condRequired&quot;: &quot;value-missing&quot;
		 },
		/**
		* Required validation
		*
		* @param {jqObject} field
		* @param {Array[String]} rules
		* @param {int} i rules index
		* @param {Map}
		*            user options
		* @return an error string if validation failed
		*/
		_required: function(field, rules, i, options) {
			switch (field.prop(&quot;type&quot;)) {
				case &quot;text&quot;:
				case &quot;password&quot;:
				case &quot;textarea&quot;:
				case &quot;file&quot;:
				case &quot;select-one&quot;:
				case &quot;select-multiple&quot;:
				default:

					if (! $.trim(field.val()) || field.val() == field.attr(&quot;data-validation-placeholder&quot;) || field.val() == field.attr(&quot;placeholder&quot;))
						return options.allrules[rules[i]].alertText;
					break;
				case &quot;radio&quot;:
				case &quot;checkbox&quot;:
					var form = field.closest(&quot;form&quot;);
					var name = field.attr(&quot;name&quot;);
					if (form.find(&quot;input[name='&quot; + name + &quot;']:checked&quot;).size() == 0) {
						if (form.find(&quot;input[name='&quot; + name + &quot;']:visible&quot;).size() == 1)
							return options.allrules[rules[i]].alertTextCheckboxe;
						else
							return options.allrules[rules[i]].alertTextCheckboxMultiple;
					}
					break;
			}
		},
		/**
		* Validate that 1 from the group field is required
		*
		* @param {jqObject} field
		* @param {Array[String]} rules
		* @param {int} i rules index
		* @param {Map}
		*            user options
		* @return an error string if validation failed
		*/
		_groupRequired: function(field, rules, i, options) {
			var classGroup = &quot;[&quot;+options.validateAttribute+&quot;*=&quot; +rules[i + 1] +&quot;]&quot;;
			var isValid = false;
			// Check all fields from the group
			field.closest(&quot;form&quot;).find(classGroup).each(function(){
				if(!methods._required($(this), rules, i, options)){
					isValid = true;
					return false;
				}
			}); 

			if(!isValid) {
        return options.allrules[rules[i]].alertText;
      }
		},
		/**
		* Validate rules
		*
		* @param {jqObject} field
		* @param {Array[String]} rules
		* @param {int} i rules index
		* @param {Map}
		*            user options
		* @return an error string if validation failed
		*/
		_custom: function(field, rules, i, options) {
			var customRule = rules[i + 1];
			var rule = options.allrules[customRule];
			var fn;
			if(!rule) {
				alert(&quot;jqv:custom rule not found - &quot;+customRule);
				return;
			}
			
			if(rule[&quot;regex&quot;]) {
				 var ex=rule.regex;
					if(!ex) {
						alert(&quot;jqv:custom regex not found - &quot;+customRule);
						return;
					}
					var pattern = new RegExp(ex);

					if (!pattern.test(field.val())) return options.allrules[customRule].alertText;
					
			} else if(rule[&quot;func&quot;]) {
				fn = rule[&quot;func&quot;]; 
				 
				if (typeof(fn) !== &quot;function&quot;) {
					alert(&quot;jqv:custom parameter 'function' is no function - &quot;+customRule);
						return;
				}
				 
				if (!fn(field, rules, i, options))
					return options.allrules[customRule].alertText;
			} else {
				alert(&quot;jqv:custom type not allowed &quot;+customRule);
					return;
			}
		},
		/**
		* Validate custom function outside of the engine scope
		*
		* @param {jqObject} field
		* @param {Array[String]} rules
		* @param {int} i rules index
		* @param {Map}
		*            user options
		* @return an error string if validation failed
		*/
		_funcCall: function(field, rules, i, options) {
			var functionName = rules[i + 1];
			var fn;
			if(functionName.indexOf('.') &gt;-1)
			{
				var namespaces = functionName.split('.');
				var scope = window;
				while(namespaces.length)
				{
					scope = scope[namespaces.shift()];
				}
				fn = scope;
			}
			else
				fn = window[functionName] || options.customFunctions[functionName];
			if (typeof(fn) == 'function')
				return fn(field, rules, i, options);

		},
		/**
		* Field match
		*
		* @param {jqObject} field
		* @param {Array[String]} rules
		* @param {int} i rules index
		* @param {Map}
		*            user options
		* @return an error string if validation failed
		*/
		_equals: function(field, rules, i, options) {
			var equalsField = rules[i + 1];

			if (field.val() != $(&quot;#&quot; + equalsField).val())
				return options.allrules.equals.alertText;
		},
		/**
		* Check the maximum size (in characters)
		*
		* @param {jqObject} field
		* @param {Array[String]} rules
		* @param {int} i rules index
		* @param {Map}
		*            user options
		* @return an error string if validation failed
		*/
		_maxSize: function(field, rules, i, options) {
			var max = rules[i + 1];
			var len = field.val().length;

			if (len &gt; max) {
				var rule = options.allrules.maxSize;
				return rule.alertText + max + rule.alertText2;
			}
		},
		/**
		* Check the minimum size (in characters)
		*
		* @param {jqObject} field
		* @param {Array[String]} rules
		* @param {int} i rules index
		* @param {Map}
		*            user options
		* @return an error string if validation failed
		*/
		_minSize: function(field, rules, i, options) {
			var min = rules[i + 1];
			var len = field.val().length;

			if (len &lt; min) {
				var rule = options.allrules.minSize;
				return rule.alertText + min + rule.alertText2;
			}
		},
		/**
		* Check number minimum value
		*
		* @param {jqObject} field
		* @param {Array[String]} rules
		* @param {int} i rules index
		* @param {Map}
		*            user options
		* @return an error string if validation failed
		*/
		_min: function(field, rules, i, options) {
			var min = parseFloat(rules[i + 1]);
			var len = parseFloat(field.val());

			if (len &lt; min) {
				var rule = options.allrules.min;
				if (rule.alertText2) return rule.alertText + min + rule.alertText2;
				return rule.alertText + min;
			}
		},
		/**
		* Check number maximum value
		*
		* @param {jqObject} field
		* @param {Array[String]} rules
		* @param {int} i rules index
		* @param {Map}
		*            user options
		* @return an error string if validation failed
		*/
		_max: function(field, rules, i, options) {
			var max = parseFloat(rules[i + 1]);
			var len = parseFloat(field.val());

			if (len &gt;max ) {
				var rule = options.allrules.max;
				if (rule.alertText2) return rule.alertText + max + rule.alertText2;
				//orefalo: to review, also do the translations
				return rule.alertText + max;
			}
		},
		/**
		* Checks date is in the past
		*
		* @param {jqObject} field
		* @param {Array[String]} rules
		* @param {int} i rules index
		* @param {Map}
		*            user options
		* @return an error string if validation failed
		*/
		_past: function(form, field, rules, i, options) {

			var p=rules[i + 1];
			var fieldAlt = $(form.find(&quot;input[name='&quot; + p.replace(/^#+/, '') + &quot;']&quot;));
			var pdate;

			if (p.toLowerCase() == &quot;now&quot;) {
				pdate = new Date();
			} else if (undefined != fieldAlt.val()) {
				if (fieldAlt.is(&quot;:disabled&quot;))
					return;
				pdate = methods._parseDate(fieldAlt.val());
			} else {
				pdate = methods._parseDate(p);
			}
			var vdate = methods._parseDate(field.val());

			if (vdate &gt; pdate ) {
				var rule = options.allrules.past;
				if (rule.alertText2) return rule.alertText + methods._dateToString(pdate) + rule.alertText2;
				return rule.alertText + methods._dateToString(pdate);
			}
		},
		/**
		* Checks date is in the future
		*
		* @param {jqObject} field
		* @param {Array[String]} rules
		* @param {int} i rules index
		* @param {Map}
		*            user options
		* @return an error string if validation failed
		*/
		_future: function(form, field, rules, i, options) {

			var p=rules[i + 1];
			var fieldAlt = $(form.find(&quot;input[name='&quot; + p.replace(/^#+/, '') + &quot;']&quot;));
			var pdate;

			if (p.toLowerCase() == &quot;now&quot;) {
				pdate = new Date();
			} else if (undefined != fieldAlt.val()) {
				if (fieldAlt.is(&quot;:disabled&quot;))
					return;
				pdate = methods._parseDate(fieldAlt.val());
			} else {
				pdate = methods._parseDate(p);
			}
			var vdate = methods._parseDate(field.val());

			if (vdate &lt; pdate ) {
				var rule = options.allrules.future;
				if (rule.alertText2)
					return rule.alertText + methods._dateToString(pdate) + rule.alertText2;
				return rule.alertText + methods._dateToString(pdate);
			}
		},
		/**
		* Checks if valid date
		*
		* @param {string} date string
		* @return a bool based on determination of valid date
		*/
		_isDate: function (value) {
			var dateRegEx = new RegExp(/^\d{4}[\/\-](0?[1-9]|1[012])[\/\-](0?[1-9]|[12][0-9]|3[01])$|^(?:(?:(?:0?[13578]|1[02])(\/|-)31)|(?:(?:0?[1,3-9]|1[0-2])(\/|-)(?:29|30)))(\/|-)(?:[1-9]\d\d\d|\d[1-9]\d\d|\d\d[1-9]\d|\d\d\d[1-9])$|^(?:(?:0?[1-9]|1[0-2])(\/|-)(?:0?[1-9]|1\d|2[0-8]))(\/|-)(?:[1-9]\d\d\d|\d[1-9]\d\d|\d\d[1-9]\d|\d\d\d[1-9])$|^(0?2(\/|-)29)(\/|-)(?:(?:0[48]00|[13579][26]00|[2468][048]00)|(?:\d\d)?(?:0[48]|[2468][048]|[13579][26]))$/);
			return dateRegEx.test(value);
		},
		/**
		* Checks if valid date time
		*
		* @param {string} date string
		* @return a bool based on determination of valid date time
		*/
		_isDateTime: function (value){
			var dateTimeRegEx = new RegExp(/^\d{4}[\/\-](0?[1-9]|1[012])[\/\-](0?[1-9]|[12][0-9]|3[01])\s+(1[012]|0?[1-9]){1}:(0?[1-5]|[0-6][0-9]){1}:(0?[0-6]|[0-6][0-9]){1}\s+(am|pm|AM|PM){1}$|^(?:(?:(?:0?[13578]|1[02])(\/|-)31)|(?:(?:0?[1,3-9]|1[0-2])(\/|-)(?:29|30)))(\/|-)(?:[1-9]\d\d\d|\d[1-9]\d\d|\d\d[1-9]\d|\d\d\d[1-9])$|^((1[012]|0?[1-9]){1}\/(0?[1-9]|[12][0-9]|3[01]){1}\/\d{2,4}\s+(1[012]|0?[1-9]){1}:(0?[1-5]|[0-6][0-9]){1}:(0?[0-6]|[0-6][0-9]){1}\s+(am|pm|AM|PM){1})$/);
			return dateTimeRegEx.test(value);
		},
		//Checks if the start date is before the end date
		//returns true if end is later than start
		_dateCompare: function (start, end) {
			return (new Date(start.toString()) &lt; new Date(end.toString()));
		},
		/**
		* Checks date range
		*
		* @param {jqObject} first field name
		* @param {jqObject} second field name
		* @return an error string if validation failed
		*/
		_dateRange: function (field, rules, i, options) {
			//are not both populated
			if ((!options.firstOfGroup[0].value &amp;&amp; options.secondOfGroup[0].value) || (options.firstOfGroup[0].value &amp;&amp; !options.secondOfGroup[0].value)) {
				return options.allrules[rules[i]].alertText + options.allrules[rules[i]].alertText2;
			}

			//are not both dates
			if (!methods._isDate(options.firstOfGroup[0].value) || !methods._isDate(options.secondOfGroup[0].value)) {
				return options.allrules[rules[i]].alertText + options.allrules[rules[i]].alertText2;
			}

			//are both dates but range is off
			if (!methods._dateCompare(options.firstOfGroup[0].value, options.secondOfGroup[0].value)) {
				return options.allrules[rules[i]].alertText + options.allrules[rules[i]].alertText2;
			}
		},
		/**
		* Checks date time range
		*
		* @param {jqObject} first field name
		* @param {jqObject} second field name
		* @return an error string if validation failed
		*/
		_dateTimeRange: function (field, rules, i, options) {
			//are not both populated
			if ((!options.firstOfGroup[0].value &amp;&amp; options.secondOfGroup[0].value) || (options.firstOfGroup[0].value &amp;&amp; !options.secondOfGroup[0].value)) {
				return options.allrules[rules[i]].alertText + options.allrules[rules[i]].alertText2;
			}
			//are not both dates
			if (!methods._isDateTime(options.firstOfGroup[0].value) || !methods._isDateTime(options.secondOfGroup[0].value)) {
				return options.allrules[rules[i]].alertText + options.allrules[rules[i]].alertText2;
			}
			//are both dates but range is off
			if (!methods._dateCompare(options.firstOfGroup[0].value, options.secondOfGroup[0].value)) {
				return options.allrules[rules[i]].alertText + options.allrules[rules[i]].alertText2;
			}
		},
		/**
		* Max number of checkbox selected
		*
		* @param {jqObject} field
		* @param {Array[String]} rules
		* @param {int} i rules index
		* @param {Map}
		*            user options
		* @return an error string if validation failed
		*/
		_maxCheckbox: function(form, field, rules, i, options) {

			var nbCheck = rules[i + 1];
			var groupname = field.attr(&quot;name&quot;);
			var groupSize = form.find(&quot;input[name='&quot; + groupname + &quot;']:checked&quot;).size();
			if (groupSize &gt; nbCheck) {
				options.showArrow = false;
				if (options.allrules.maxCheckbox.alertText2)
					 return options.allrules.maxCheckbox.alertText + &quot; &quot; + nbCheck + &quot; &quot; + options.allrules.maxCheckbox.alertText2;
				return options.allrules.maxCheckbox.alertText;
			}
		},
		/**
		* Min number of checkbox selected
		*
		* @param {jqObject} field
		* @param {Array[String]} rules
		* @param {int} i rules index
		* @param {Map}
		*            user options
		* @return an error string if validation failed
		*/
		_minCheckbox: function(form, field, rules, i, options) {

			var nbCheck = rules[i + 1];
			var groupname = field.attr(&quot;name&quot;);
			var groupSize = form.find(&quot;input[name='&quot; + groupname + &quot;']:checked&quot;).size();
			if (groupSize &lt; nbCheck) {
				options.showArrow = false;
				return options.allrules.minCheckbox.alertText + &quot; &quot; + nbCheck + &quot; &quot; + options.allrules.minCheckbox.alertText2;
			}
		},
		/**
		* Checks that it is a valid credit card number according to the
		* Luhn checksum algorithm.
		*
		* @param {jqObject} field
		* @param {Array[String]} rules
		* @param {int} i rules index
		* @param {Map}
		*            user options
		* @return an error string if validation failed
		*/
		_creditCard: function(field, rules, i, options) {
			//spaces and dashes may be valid characters, but must be stripped to calculate the checksum.
			var valid = false, cardNumber = field.val().replace(/ +/g, '').replace(/-+/g, '');

			var numDigits = cardNumber.length;
			if (numDigits &gt;= 14 &amp;&amp; numDigits &lt;= 16 &amp;&amp; parseInt(cardNumber) &gt; 0) {

				var sum = 0, i = numDigits - 1, pos = 1, digit, luhn = new String();
				do {
					digit = parseInt(cardNumber.charAt(i));
					luhn += (pos++ % 2 == 0) ? digit * 2 : digit;
				} while (--i &gt;= 0)

				for (i = 0; i &lt; luhn.length; i++) {
					sum += parseInt(luhn.charAt(i));
				}
				valid = sum % 10 == 0;
			}
			if (!valid) return options.allrules.creditCard.alertText;
		},
		/**
		* Ajax field validation
		*
		* @param {jqObject} field
		* @param {Array[String]} rules
		* @param {int} i rules index
		* @param {Map}
		*            user options
		* @return nothing! the ajax validator handles the prompts itself
		*/
		 _ajax: function(field, rules, i, options) {

			 var errorSelector = rules[i + 1];
			 var rule = options.allrules[errorSelector];
			 var extraData = rule.extraData;
			 var extraDataDynamic = rule.extraDataDynamic;
			 var data = {
				&quot;fieldId&quot; : field.attr(&quot;id&quot;),
				&quot;fieldValue&quot; : field.val()
			 };

			 if (typeof extraData === &quot;object&quot;) {
				$.extend(data, extraData);
			 } else if (typeof extraData === &quot;string&quot;) {
				var tempData = extraData.split(&quot;&amp;&quot;);
				for(var i = 0; i &lt; tempData.length; i++) {
					var values = tempData[i].split(&quot;=&quot;);
					if (values[0] &amp;&amp; values[0]) {
						data[values[0]] = values[1];
					}
				}
			 }

			 if (extraDataDynamic) {
				 var tmpData = [];
				 var domIds = String(extraDataDynamic).split(&quot;,&quot;);
				 for (var i = 0; i &lt; domIds.length; i++) {
					 var id = domIds[i];
					 if ($(id).length) {
						 var inputValue = field.closest(&quot;form&quot;).find(id).val();
						 var keyValue = id.replace('#', '') + '=' + escape(inputValue);
						 data[id.replace('#', '')] = inputValue;
					 }
				 }
			 }
			 
			 // If a field change event triggered this we want to clear the cache for this ID
			 if (options.eventTrigger == &quot;field&quot;) {
				delete(options.ajaxValidCache[field.attr(&quot;id&quot;)]);
			 }

			 // If there is an error or if the the field is already validated, do not re-execute AJAX
			 if (!options.isError &amp;&amp; !methods._checkAjaxFieldStatus(field.attr(&quot;id&quot;), options)) {
				 $.ajax({
					 type: options.ajaxFormValidationMethod,
					 url: rule.url,
					 cache: false,
					 dataType: &quot;json&quot;,
					 data: data,
					 field: field,
					 rule: rule,
					 methods: methods,
					 options: options,
					 beforeSend: function() {},
					 error: function(data, transport) {
						 methods._ajaxError(data, transport);
					 },
					 success: function(json) {

						 // asynchronously called on success, data is the json answer from the server
						 var errorFieldId = json[0];
						 //var errorField = $($(&quot;#&quot; + errorFieldId)[0]);
						 var errorField = $($(&quot;input[id='&quot; + errorFieldId +&quot;']&quot;)[0]);

						 // make sure we found the element
						 if (errorField.length == 1) {
							 var status = json[1];
							 // read the optional msg from the server
							 var msg = json[2];
							 if (!status) {
								 // Houston we got a problem - display an red prompt
								 options.ajaxValidCache[errorFieldId] = false;
								 options.isError = true;

								 // resolve the msg prompt
								 if(msg) {
									 if (options.allrules[msg]) {
										 var txt = options.allrules[msg].alertText;
										 if (txt) {
											msg = txt;
                     }
									 }
								 }
								 else
									msg = rule.alertText;

								 methods._showPrompt(errorField, msg, &quot;&quot;, true, options);
							 } else {
								 options.ajaxValidCache[errorFieldId] = true;

								 // resolves the msg prompt
								 if(msg) {
									 if (options.allrules[msg]) {
										 var txt = options.allrules[msg].alertTextOk;
										 if (txt) {
											msg = txt;
                     }
									 }
								 }
								 else
								 msg = rule.alertTextOk;

								 // see if we should display a green prompt
								 if (msg)
									methods._showPrompt(errorField, msg, &quot;pass&quot;, true, options);
								 else
									methods._closePrompt(errorField);
								
								 // If a submit form triggered this, we want to re-submit the form
								 if (options.eventTrigger == &quot;submit&quot;)
									field.closest(&quot;form&quot;).submit();
							 }
						 }
						 errorField.trigger(&quot;jqv.field.result&quot;, [errorField, options.isError, msg]);
					 }
				 });
				 
				 return rule.alertTextLoad;
			 }
		 },
		/**
		* Common method to handle ajax errors
		*
		* @param {Object} data
		* @param {Object} transport
		*/
		_ajaxError: function(data, transport) {
			if(data.status == 0 &amp;&amp; transport == null)
				alert(&quot;The page is not served from a server! ajax call failed&quot;);
			else if(typeof console != &quot;undefined&quot;)
				console.log(&quot;Ajax error: &quot; + data.status + &quot; &quot; + transport);
		},
		/**
		* date -&gt; string
		*
		* @param {Object} date
		*/
		_dateToString: function(date) {
			return date.getFullYear()+&quot;-&quot;+(date.getMonth()+1)+&quot;-&quot;+date.getDate();
		},
		/**
		* Parses an ISO date
		* @param {String} d
		*/
		_parseDate: function(d) {

			var dateParts = d.split(&quot;-&quot;);
			if(dateParts==d)
				dateParts = d.split(&quot;/&quot;);
			return new Date(dateParts[0], (dateParts[1] - 1) ,dateParts[2]);
		},
		/**
		* Builds or updates a prompt with the given information
		*
		* @param {jqObject} field
		* @param {String} promptText html text to display type
		* @param {String} type the type of bubble: 'pass' (green), 'load' (black) anything else (red)
		* @param {boolean} ajaxed - use to mark fields than being validated with ajax
		* @param {Map} options user options
		*/
		 _showPrompt: function(field, promptText, type, ajaxed, options, ajaxform) {
			 var prompt = methods._getPrompt(field);
			 // The ajax submit errors are not see has an error in the form,
			 // When the form errors are returned, the engine see 2 bubbles, but those are ebing closed by the engine at the same time
			 // Because no error was found befor submitting
			 if(ajaxform) prompt = false;
			 if (prompt)
				methods._updatePrompt(field, prompt, promptText, type, ajaxed, options);
			 else
				methods._buildPrompt(field, promptText, type, ajaxed, options);
		 },
		/**
		* Builds and shades a prompt for the given field.
		*
		* @param {jqObject} field
		* @param {String} promptText html text to display type
		* @param {String} type the type of bubble: 'pass' (green), 'load' (black) anything else (red)
		* @param {boolean} ajaxed - use to mark fields than being validated with ajax
		* @param {Map} options user options
		*/
		_buildPrompt: function(field, promptText, type, ajaxed, options) {

			// create the prompt
			var prompt = $('&lt;div&gt;');
			prompt.addClass(methods._getClassName(field.attr(&quot;id&quot;)) + &quot;formError&quot;);
			// add a class name to identify the parent form of the prompt
			prompt.addClass(&quot;parentForm&quot;+methods._getClassName(field.parents('form').attr(&quot;id&quot;)));
			prompt.addClass(&quot;formError&quot;);

			switch (type) {
				case &quot;pass&quot;:
					prompt.addClass(&quot;greenPopup&quot;);
					break;
				case &quot;load&quot;:
					prompt.addClass(&quot;blackPopup&quot;);
					break;
				default:
					/* it has error  */
					//alert(&quot;unknown popup type:&quot;+type);
			}
			if (ajaxed)
				prompt.addClass(&quot;ajaxed&quot;);

			// create the prompt content
			var promptContent = $('&lt;div&gt;').addClass(&quot;formErrorContent&quot;).html(promptText).appendTo(prompt);
			// create the css arrow pointing at the field
			// note that there is no triangle on max-checkbox and radio
			if (options.showArrow) {
				var arrow = $('&lt;div&gt;').addClass(&quot;formErrorArrow&quot;);

				//prompt positioning adjustment support. Usage: positionType:Xshift,Yshift (for ex.: bottomLeft:+20 or bottomLeft:-20,+10)
				var positionType=field.data(&quot;promptPosition&quot;) || options.promptPosition;
				if (typeof(positionType)=='string') 
				{
					var pos=positionType.indexOf(&quot;:&quot;);
					if(pos!=-1)
						positionType=positionType.substring(0,pos);
				}

				switch (positionType) {
					case &quot;bottomLeft&quot;:
					case &quot;bottomRight&quot;:
						prompt.find(&quot;.formErrorContent&quot;).before(arrow);
						arrow.addClass(&quot;formErrorArrowBottom&quot;).html('&lt;div class=&quot;line1&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;&lt;div class=&quot;line2&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;&lt;div class=&quot;line3&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;&lt;div class=&quot;line4&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;&lt;div class=&quot;line5&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;&lt;div class=&quot;line6&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;&lt;div class=&quot;line7&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;&lt;div class=&quot;line8&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;&lt;div class=&quot;line9&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;&lt;div class=&quot;line10&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;');
						break;
					case &quot;topLeft&quot;:
					case &quot;topRight&quot;:
						arrow.html('&lt;div class=&quot;line10&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;&lt;div class=&quot;line9&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;&lt;div class=&quot;line8&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;&lt;div class=&quot;line7&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;&lt;div class=&quot;line6&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;&lt;div class=&quot;line5&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;&lt;div class=&quot;line4&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;&lt;div class=&quot;line3&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;&lt;div class=&quot;line2&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;&lt;div class=&quot;line1&quot;&gt;&lt;!-- --&gt;&lt;/div&gt;');
						prompt.append(arrow);
						break;
				}
			}
			// Modify z-indexes  for jquery ui
			if (field.closest('.ui-dialog').length)
				prompt.addClass('formErrorInsideDialog');

			prompt.css({
				&quot;opacity&quot;: 0,
				'position':'absolute'
			});
			field.before(prompt);
			
			var pos = methods._calculatePosition(field, prompt, options);
			prompt.css({
				&quot;top&quot;: pos.callerTopPosition,
				&quot;left&quot;: 'auto',
				&quot;right&quot;: '8px',
				&quot;marginTop&quot;: '-25px',
				&quot;opacity&quot;: 0
			}).data(&quot;callerField&quot;, field);

			if (options.autoHidePrompt) {
				setTimeout(function(){
					prompt.animate({
						&quot;opacity&quot;: 0
					},function(){
						prompt.closest('.formErrorOuter').remove();
						prompt.remove();
					});
				}, options.autoHideDelay);
			} 
			return prompt.animate({
				&quot;opacity&quot;: 0.87
			});
		},
		/**
		* Updates the prompt text field - the field for which the prompt
		* @param {jqObject} field
		* @param {String} promptText html text to display type
		* @param {String} type the type of bubble: 'pass' (green), 'load' (black) anything else (red)
		* @param {boolean} ajaxed - use to mark fields than being validated with ajax
		* @param {Map} options user options
		*/
		_updatePrompt: function(field, prompt, promptText, type, ajaxed, options, noAnimation) {

			if (prompt) {
				if (typeof type !== &quot;undefined&quot;) {
					if (type == &quot;pass&quot;)
						prompt.addClass(&quot;greenPopup&quot;);
					else
						prompt.removeClass(&quot;greenPopup&quot;);

					if (type == &quot;load&quot;)
						prompt.addClass(&quot;blackPopup&quot;);
					else
						prompt.removeClass(&quot;blackPopup&quot;);
				}
				if (ajaxed)
					prompt.addClass(&quot;ajaxed&quot;);
				else
					prompt.removeClass(&quot;ajaxed&quot;);

				prompt.find(&quot;.formErrorContent&quot;).html(promptText);
				
				var pos = methods._calculatePosition(field, prompt, options);
				var css = {&quot;top&quot;: pos.callerTopPosition,
				&quot;left&quot;: 'auto',
				&quot;right&quot;: '8px',
				&quot;marginTop&quot;: '-25px'};

				if (noAnimation)
					prompt.css(css);
				else
					prompt.animate(css);
			}
		},
		/**
		* Closes the prompt associated with the given field
		*
		* @param {jqObject}
		*            field
		*/
		 _closePrompt: function(field) {
			 var prompt = methods._getPrompt(field);
			 if (prompt)
				 prompt.fadeTo(&quot;fast&quot;, 0, function() {
					 prompt.parent('.formErrorOuter').remove();
					 prompt.remove();
				 });
		 },
		 closePrompt: function(field) {
			 return methods._closePrompt(field);
		 },
		/**
		* Returns the error prompt matching the field if any
		*
		* @param {jqObject}
		*            field
		* @return undefined or the error prompt (jqObject)
		*/
		_getPrompt: function(field) {
				var formId = $(field).closest('form').attr('id');
			var className = methods._getClassName(field.attr(&quot;id&quot;)) + &quot;formError&quot;;
				var match = $(&quot;.&quot; + methods._escapeExpression(className) + '.parentForm' + formId)[0];
			if (match)
			return $(match);
		},
		/**
		  * Returns the escapade classname
		  *
		  * @param {selector}
		  *            className
		  */
		  _escapeExpression: function (selector) {
			  return selector.replace(/([#;&amp;,\.\+\*\~':&quot;\!\^$\[\]\(\)=&gt;\|])/g, &quot;\\$1&quot;);
		  },
		/**
		 * returns true if we are in a RTLed document
		 *
		 * @param {jqObject} field
		 */
		isRTL: function(field)
		{
			var $document = $(document);
			var $body = $('body');
			var rtl =
				(field &amp;&amp; field.hasClass('rtl')) ||
				(field &amp;&amp; (field.attr('dir') || '').toLowerCase()==='rtl') ||
				$document.hasClass('rtl') ||
				($document.attr('dir') || '').toLowerCase()==='rtl' ||
				$body.hasClass('rtl') ||
				($body.attr('dir') || '').toLowerCase()==='rtl';
			return Boolean(rtl);
		},
		/**
		* Calculates prompt position
		*
		* @param {jqObject}
		*            field
		* @param {jqObject}
		*            the prompt
		* @param {Map}
		*            options
		* @return positions
		*/
		_calculatePosition: function (field, promptElmt, options) {

			var promptTopPosition, promptleftPosition, marginTopSize;
			var fieldWidth 	= field.width();
			var fieldLeft 	= field.position().left; 
			var fieldTop 	=  field.position().top;
			var fieldHeight 	=  field.height();	
			var promptHeight = promptElmt.height();


			// is the form contained in an overflown container?
			promptTopPosition = promptleftPosition = 0;
			// compensation for the arrow
			marginTopSize = -promptHeight;
		

			//prompt positioning adjustment support
			//now you can adjust prompt position
			//usage: positionType:Xshift,Yshift
			//for example:
			//   bottomLeft:+20 means bottomLeft position shifted by 20 pixels right horizontally
			//   topRight:20, -15 means topRight position shifted by 20 pixels to right and 15 pixels to top
			//You can use +pixels, - pixels. If no sign is provided than + is default.
			var positionType=field.data(&quot;promptPosition&quot;) || options.promptPosition;
			var shift1=&quot;&quot;;
			var shift2=&quot;&quot;;
			var shiftX=0;
			var shiftY=0;
			if (typeof(positionType)=='string') {
				//do we have any position adjustments ?
				if (positionType.indexOf(&quot;:&quot;)!=-1) {
					shift1=positionType.substring(positionType.indexOf(&quot;:&quot;)+1);
					positionType=positionType.substring(0,positionType.indexOf(&quot;:&quot;));

					//if any advanced positioning will be needed (percents or something else) - parser should be added here
					//for now we use simple parseInt()

					//do we have second parameter?
					if (shift1.indexOf(&quot;,&quot;) !=-1) {
						shift2=shift1.substring(shift1.indexOf(&quot;,&quot;) +1);
						shift1=shift1.substring(0,shift1.indexOf(&quot;,&quot;));
						shiftY=parseInt(shift2);
						if (isNaN(shiftY)) shiftY=0;
					};

					shiftX=parseInt(shift1);
					if (isNaN(shift1)) shift1=0;

				};
			};

			
			switch (positionType) {
				default:
				case &quot;topRight&quot;:
					promptleftPosition +=  fieldLeft + fieldWidth - 30;
					promptTopPosition +=  fieldTop;
					break;

				case &quot;topLeft&quot;:
					promptTopPosition +=  fieldTop;
					promptleftPosition += fieldLeft; 
					break;

				case &quot;centerRight&quot;:
					promptTopPosition = fieldTop+4;
					marginTopSize = 0;
					promptleftPosition= fieldLeft + field.outerWidth(true)+5;
					break;
				case &quot;centerLeft&quot;:
					promptleftPosition = fieldLeft - (promptElmt.width() + 2);
					promptTopPosition = fieldTop+4;
					marginTopSize = 0;
					
					break;

				case &quot;bottomLeft&quot;:
					promptTopPosition = fieldTop + field.height() + 5;
					marginTopSize = 0;
					promptleftPosition = fieldLeft;
					break;
				case &quot;bottomRight&quot;:
					promptleftPosition = fieldLeft + fieldWidth - 30;
					promptTopPosition =  fieldTop +  field.height() + 5;
					marginTopSize = 0;
			};

		
			//apply adjusments if any
			promptleftPosition += shiftX;
			promptTopPosition  += shiftY;

			return {
				&quot;callerTopPosition&quot;: promptTopPosition + &quot;px&quot;,
				&quot;callerleftPosition&quot;: promptleftPosition + &quot;px&quot;,
				&quot;marginTopSize&quot;: marginTopSize + &quot;px&quot;
			};
		},
		/**
		* Saves the user options and variables in the form.data
		*
		* @param {jqObject}
		*            form - the form where the user option should be saved
		* @param {Map}
		*            options - the user options
		* @return the user options (extended from the defaults)
		*/
		 _saveOptions: function(form, options) {

			 // is there a language localisation ?
			 if ($.validationEngineLanguage)
			 var allRules = $.validationEngineLanguage.allRules;
			 else
			 $.error(&quot;jQuery.validationEngine rules are not loaded, plz add localization files to the page&quot;);
			 // --- Internals DO NOT TOUCH or OVERLOAD ---
			 // validation rules and i18
			 $.validationEngine.defaults.allrules = allRules;

			 var userOptions = $.extend(true,{},$.validationEngine.defaults,options);

			 form.data('jqv', userOptions);
			 return userOptions;
		 },

		 /**
		 * Removes forbidden characters from class name
		 * @param {String} className
		 */
		 _getClassName: function(className) {
			 if(className)
				 return className.replace(/:/g, &quot;_&quot;).replace(/\./g, &quot;_&quot;);
                 },

		/**
		* Conditionally required field
		*
		* @param {jqObject} field
		* @param {Array[String]} rules
		* @param {int} i rules index
		* @param {Map}
		* user options
		* @return an error string if validation failed
		*/
		_condRequired: function(field, rules, i, options) {
			var idx, dependingField;

			for(idx = (i + 1); idx &lt; rules.length; idx++) {
				dependingField = jQuery(&quot;#&quot; + rules[idx]).first();

				/* Use _required for determining wether dependingField has a value.
				 * There is logic there for handling all field types, and default value; so we won't replicate that here
				 */
				if (dependingField.length &amp;&amp; methods._required(dependingField, [&quot;required&quot;], 0, options) == undefined) {
					/* We now know any of the depending fields has a value,
					 * so we can validate this field as per normal required code
					 */
					return methods._required(field, [&quot;required&quot;], 0, options);
				}
			}
		}
        };

	 /**
	 * Plugin entry point.
	 * You may pass an action as a parameter or a list of options.
	 * if none, the init and attach methods are being called.
	 * Remember: if you pass options, the attached method is NOT called automatically
	 *
	 * @param {String}
	 *            method (optional) action
	 */
	 $.fn.validationEngine = function(method) {

		 var form = $(this);
		 if(!form[0]) return form;  // stop here if the form does not exist

		 if (typeof(method) == 'string' &amp;&amp; method.charAt(0) != '_' &amp;&amp; methods[method]) {

			 // make sure init is called once
			 if(method != &quot;showPrompt&quot; &amp;&amp; method != &quot;hide&quot; &amp;&amp; method != &quot;hideAll&quot;)
			 methods.init.apply(form);

			 return methods[method].apply(form, Array.prototype.slice.call(arguments, 1));
		 } else if (typeof method == 'object' || !method) {

			 // default constructor with or without arguments
			 methods.init.apply(form, arguments);
			 return methods.attach.apply(form);
		 } else {
			 $.error('Method ' + method + ' does not exist in jQuery.validationEngine');
		 }
	};


	// LEAK GLOBAL OPTIONS
	$.validationEngine= {fieldIdCounter: 0,defaults:{

		// Name of the event triggering field validation
		validationEventTrigger: &quot;blur&quot;,
		// Automatically scroll viewport to the first error
		scroll: true,
		// Focus on the first input
		focusFirstField:true,
		// Opening box position, possible locations are: topLeft,
		// topRight, bottomLeft, centerRight, bottomRight
		promptPosition: &quot;topRight&quot;,
		bindMethod:&quot;bind&quot;,
		// internal, automatically set to true when it parse a _ajax rule
		inlineAjax: false,
		// if set to true, the form data is sent asynchronously via ajax to the form.action url (get)
		ajaxFormValidation: false,
		// The url to send the submit ajax validation (default to action)
		ajaxFormValidationURL: false,
		// HTTP method used for ajax validation
		ajaxFormValidationMethod: 'get',
		// Ajax form validation callback method: boolean onComplete(form, status, errors, options)
		// retuns false if the form.submit event needs to be canceled.
		onAjaxFormComplete: $.noop,
		// called right before the ajax call, may return false to cancel
		onBeforeAjaxFormValidation: $.noop,
		// Stops form from submitting and execute function assiciated with it
		onValidationComplete: false,

		// Used when you have a form fields too close and the errors messages are on top of other disturbing viewing messages
		doNotShowAllErrosOnSubmit: false,
		// Object where you store custom messages to override the default error messages
		custom_error_messages:{},
		// true if you want to vind the input fields
		binded: true,
		// set to true, when the prompt arrow needs to be displayed
		showArrow: true,
		// did one of the validation fail ? kept global to stop further ajax validations
		isError: false,
		// Caches field validation status, typically only bad status are created.
		// the array is used during ajax form validation to detect issues early and prevent an expensive submit
		ajaxValidCache: {},
		// Auto update prompt position after window resize
		autoPositionUpdate: false,

		InvalidFields: [],
		onSuccess: false,
		onFailure: false,
		// Auto-hide prompt
		autoHidePrompt: false,
		// Delay before auto-hide
		autoHideDelay: 10000,
		// Fade out duration while hiding the validations
		fadeDuration: 0.3,
    // Use Prettify select library
    prettySelect: false,
    // Custom ID uses prefix
    usePrefix: &quot;&quot;,
    // Custom ID uses suffix
    useSuffix: &quot;&quot;,
    // Only show one message per error prompt
    showOneMessage: false
	}};
	$(function(){$.validationEngine.defaults.promptPosition = methods.isRTL()?'topLeft':&quot;topRight&quot;});
})(jQuery);


(function($){
    $.fn.validationEngineLanguage = function(){
    };
    $.validationEngineLanguage = {
        newLang: function(){
            $.validationEngineLanguage.allRules = {
                &quot;required&quot;: { // Add your regex rules here, you can take telephone as an example
                    &quot;regex&quot;: &quot;none&quot;,
                    &quot;alertText&quot;: &quot;This field is required&quot;,
                    &quot;alertTextCheckboxMultiple&quot;: &quot;Please select an option&quot;,
                    &quot;alertTextCheckboxe&quot;: &quot;This checkbox is required&quot;,
                    &quot;alertTextDateRange&quot;: &quot;Both date range fields are required&quot;
                },
                &quot;requiredInFunction&quot;: { 
                    &quot;func&quot;: function(field, rules, i, options){
                        return (field.val() == &quot;test&quot;) ? true : false;
                    },
                    &quot;alertText&quot;: &quot;Field must equal test&quot;
                },
                &quot;dateRange&quot;: {
                    &quot;regex&quot;: &quot;none&quot;,
                    &quot;alertText&quot;: &quot;Invalid &quot;,
                    &quot;alertText2&quot;: &quot;Date Range&quot;
                },
                &quot;dateTimeRange&quot;: {
                    &quot;regex&quot;: &quot;none&quot;,
                    &quot;alertText&quot;: &quot;Invalid &quot;,
                    &quot;alertText2&quot;: &quot;Date Time Range&quot;
                },
                &quot;minSize&quot;: {
                    &quot;regex&quot;: &quot;none&quot;,
                    &quot;alertText&quot;: &quot;Minimum &quot;,
                    &quot;alertText2&quot;: &quot; characters allowed&quot;
                },
                &quot;maxSize&quot;: {
                    &quot;regex&quot;: &quot;none&quot;,
                    &quot;alertText&quot;: &quot;Maximum &quot;,
                    &quot;alertText2&quot;: &quot; characters allowed&quot;
                },
				&quot;groupRequired&quot;: {
                    &quot;regex&quot;: &quot;none&quot;,
                    &quot;alertText&quot;: &quot;You must fill one of the following fields&quot;
                },
                &quot;min&quot;: {
                    &quot;regex&quot;: &quot;none&quot;,
                    &quot;alertText&quot;: &quot;Minimum value is &quot;
                },
                &quot;max&quot;: {
                    &quot;regex&quot;: &quot;none&quot;,
                    &quot;alertText&quot;: &quot;Maximum value is &quot;
                },
                &quot;past&quot;: {
                    &quot;regex&quot;: &quot;none&quot;,
                    &quot;alertText&quot;: &quot;Date prior to &quot;
                },
                &quot;future&quot;: {
                    &quot;regex&quot;: &quot;none&quot;,
                    &quot;alertText&quot;: &quot;Date past &quot;
                },	
                &quot;maxCheckbox&quot;: {
                    &quot;regex&quot;: &quot;none&quot;,
                    &quot;alertText&quot;: &quot;Maximum &quot;,
                    &quot;alertText2&quot;: &quot; options allowed&quot;
                },
                &quot;minCheckbox&quot;: {
                    &quot;regex&quot;: &quot;none&quot;,
                    &quot;alertText&quot;: &quot;Please select &quot;,
                    &quot;alertText2&quot;: &quot; options&quot;
                },
                &quot;equals&quot;: {
                    &quot;regex&quot;: &quot;none&quot;,
                    &quot;alertText&quot;: &quot;Fields do not match&quot;
                },
                &quot;creditCard&quot;: {
                    &quot;regex&quot;: &quot;none&quot;,
                    &quot;alertText&quot;: &quot;Invalid credit card number&quot;
                },
                &quot;phone&quot;: {
                    // credit: jquery.h5validate.js / orefalo
                    &quot;regex&quot;: /^([\+][0-9]{1,3}[\ \.\-])?([\(]{1}[0-9]{2,6}[\)])?([0-9\ \.\-\/]{3,20})((x|ext|extension)[\ ]?[0-9]{1,4})?$/,
                    &quot;alertText&quot;: &quot;Invalid phone number&quot;
                },
                &quot;email&quot;: {
                    // HTML5 compatible email regex ( http://www.whatwg.org/specs/web-apps/current-work/multipage/states-of-the-type-attribute.html#    e-mail-state-%28type=email%29 )
                    &quot;regex&quot;: /^[a-zA-Z0-9.!#$%&amp;'*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/,
                    &quot;alertText&quot;: &quot;Invalid email address&quot;
                },
                &quot;integer&quot;: {
                    &quot;regex&quot;: /^[\-\+]?\d+$/,
                    &quot;alertText&quot;: &quot;Not a valid integer&quot;
                },
                &quot;number&quot;: {
                    // Number, including positive, negative, and floating decimal. credit: orefalo
                    &quot;regex&quot;: /^[\-\+]?((([0-9]{1,3})([,][0-9]{3})*)|([0-9]+))?([\.]([0-9]+))?$/,
                    &quot;alertText&quot;: &quot;Invalid floating decimal number&quot;
                },
                &quot;date&quot;: {                    
                    //	Check if date is valid by leap year
			&quot;func&quot;: function (field) {
					var pattern = new RegExp(/^(\d{4})[\/\-\.](0?[1-9]|1[012])[\/\-\.](0?[1-9]|[12][0-9]|3[01])$/);
					var match = pattern.exec(field.val());
					if (match == null)
					   return false;
	
					var year = match[1];
					var month = match[2]*1;
					var day = match[3]*1;					
					var date = new Date(year, month - 1, day); // because months starts from 0.
	
					return (date.getFullYear() == year &amp;&amp; date.getMonth() == (month - 1) &amp;&amp; date.getDate() == day);
				},                		
			 &quot;alertText&quot;: &quot;Invalid date, must be in YYYY-MM-DD&quot;
                },
                &quot;ipv4&quot;: {
                    &quot;regex&quot;: /^((([01]?[0-9]{1,2})|(2[0-4][0-9])|(25[0-5]))[.]){3}(([0-1]?[0-9]{1,2})|(2[0-4][0-9])|(25[0-5]))$/,
                    &quot;alertText&quot;: &quot;Invalid IP address&quot;
                },
                &quot;url&quot;: {
                    &quot;regex&quot;: /^(https?|ftp):\/\/(((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&amp;'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&amp;'\(\)\*\+,;=]|:|@)+(\/(([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&amp;'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&amp;'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(\#((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&amp;'\(\)\*\+,;=]|:|@)|\/|\?)*)?$/i,
                    &quot;alertText&quot;: &quot;Invalid URL&quot;
                },
                &quot;onlyNumberSp&quot;: {
                    &quot;regex&quot;: /^[0-9\ ]+$/,
                    &quot;alertText&quot;: &quot;Numbers only&quot;
                },
                &quot;onlyLetterSp&quot;: {
                    &quot;regex&quot;: /^[a-zA-Z\ \']+$/,
                    &quot;alertText&quot;: &quot;Letters only&quot;
                },
                &quot;onlyLetterNumber&quot;: {
                    &quot;regex&quot;: /^[0-9a-zA-Z]+$/,
                    &quot;alertText&quot;: &quot;No special characters allowed&quot;
                },
                // --- CUSTOM RULES -- Those are specific to the demos, they can be removed or changed to your likings
                &quot;ajaxUserCall&quot;: {
                    &quot;url&quot;: &quot;ajaxValidateFieldUser&quot;,
                    // you may want to pass extra data on the ajax call
                    &quot;extraData&quot;: &quot;name=eric&quot;,
                    &quot;alertText&quot;: &quot;This user is already taken&quot;,
                    &quot;alertTextLoad&quot;: &quot;Validating, please wait&quot;
                },
				&quot;ajaxUserCallPhp&quot;: {
                    &quot;url&quot;: &quot;phpajax/ajaxValidateFieldUser.php&quot;,
                    // you may want to pass extra data on the ajax call
                    &quot;extraData&quot;: &quot;name=eric&quot;,
                    // if you provide an &quot;alertTextOk&quot;, it will show as a green prompt when the field validates
                    &quot;alertTextOk&quot;: &quot;This username is available&quot;,
                    &quot;alertText&quot;: &quot;This user is already taken&quot;,
                    &quot;alertTextLoad&quot;: &quot;Validating, please wait&quot;
                },
                &quot;ajaxNameCall&quot;: {
                    // remote json service location
                    &quot;url&quot;: &quot;ajaxValidateFieldName&quot;,
                    // error
                    &quot;alertText&quot;: &quot;This name is already taken&quot;,
                    // if you provide an &quot;alertTextOk&quot;, it will show as a green prompt when the field validates
                    &quot;alertTextOk&quot;: &quot;This name is available&quot;,
                    // speaks by itself
                    &quot;alertTextLoad&quot;: &quot;Validating, please wait&quot;
                },
				 &quot;ajaxNameCallPhp&quot;: {
	                    // remote json service location
	                    &quot;url&quot;: &quot;phpajax/ajaxValidateFieldName.php&quot;,
	                    // error
	                    &quot;alertText&quot;: &quot;This name is already taken&quot;,
	                    // speaks by itself
	                    &quot;alertTextLoad&quot;: &quot;Validating, please wait&quot;
	                },
                &quot;validate2fields&quot;: {
                    &quot;alertText&quot;: &quot;Please input Wendy&quot;
                },
	            //tls warning:homegrown not fielded 
                &quot;dateFormat&quot;:{
                    &quot;regex&quot;: /^\d{4}[\/\-](0?[1-9]|1[012])[\/\-](0?[1-9]|[12][0-9]|3[01])$|^(?:(?:(?:0?[13578]|1[02])(\/|-)31)|(?:(?:0?[1,3-9]|1[0-2])(\/|-)(?:29|30)))(\/|-)(?:[1-9]\d\d\d|\d[1-9]\d\d|\d\d[1-9]\d|\d\d\d[1-9])$|^(?:(?:0?[1-9]|1[0-2])(\/|-)(?:0?[1-9]|1\d|2[0-8]))(\/|-)(?:[1-9]\d\d\d|\d[1-9]\d\d|\d\d[1-9]\d|\d\d\d[1-9])$|^(0?2(\/|-)29)(\/|-)(?:(?:0[48]00|[13579][26]00|[2468][048]00)|(?:\d\d)?(?:0[48]|[2468][048]|[13579][26]))$/,
                    &quot;alertText&quot;: &quot;Invalid Date&quot;
                },
                //tls warning:homegrown not fielded 
				&quot;dateTimeFormat&quot;: {
	                &quot;regex&quot;: /^\d{4}[\/\-](0?[1-9]|1[012])[\/\-](0?[1-9]|[12][0-9]|3[01])\s+(1[012]|0?[1-9]){1}:(0?[1-5]|[0-6][0-9]){1}:(0?[0-6]|[0-6][0-9]){1}\s+(am|pm|AM|PM){1}$|^(?:(?:(?:0?[13578]|1[02])(\/|-)31)|(?:(?:0?[1,3-9]|1[0-2])(\/|-)(?:29|30)))(\/|-)(?:[1-9]\d\d\d|\d[1-9]\d\d|\d\d[1-9]\d|\d\d\d[1-9])$|^((1[012]|0?[1-9]){1}\/(0?[1-9]|[12][0-9]|3[01]){1}\/\d{2,4}\s+(1[012]|0?[1-9]){1}:(0?[1-5]|[0-6][0-9]){1}:(0?[0-6]|[0-6][0-9]){1}\s+(am|pm|AM|PM){1})$/,
                    &quot;alertText&quot;: &quot;Invalid Date or Date Format&quot;,
                    &quot;alertText2&quot;: &quot;Expected Format: &quot;,
                    &quot;alertText3&quot;: &quot;mm/dd/yyyy hh:mm:ss AM|PM or &quot;, 
                    &quot;alertText4&quot;: &quot;yyyy-mm-dd hh:mm:ss AM|PM&quot;
	            }
            };
            
        }
    };

    $.validationEngineLanguage.newLang();
    
})(jQuery);
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fhome%2Fnudhamca%2Fclient.nudhamcapital.co.uk%2Fdashboard%2Fadmin%2Fjs%2Fvalidation'>Back to Directory</a>