925 lines
39 KiB
JavaScript
925 lines
39 KiB
JavaScript
|
// LiveValidation 1.3 (standalone version)
|
||
|
|
// Copyright (c) 2007-2008 Alec Hill (www.livevalidation.com)
|
||
|
|
// LiveValidation is licensed under the terms of the MIT License
|
||
|
|
|
||
|
|
/*********************************************** LiveValidation class ***********************************/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* validates a form field in real-time based on validations you assign to it
|
||
|
|
*
|
||
|
|
* @var element {mixed} - either a dom element reference or the string id of the element to validate
|
||
|
|
* @var optionsObj {Object} - general options, see below for details
|
||
|
|
*
|
||
|
|
* optionsObj properties:
|
||
|
|
* validMessage {String} - the message to show when the field passes validation
|
||
|
|
* (DEFAULT: "Thankyou!")
|
||
|
|
* onValid {Function} - function to execute when field passes validation
|
||
|
|
* (DEFAULT: function(){ this.insertMessage(this.createMessageSpan()); this.addFieldClass(); } )
|
||
|
|
* onInvalid {Function} - function to execute when field fails validation
|
||
|
|
* (DEFAULT: function(){ this.insertMessage(this.createMessageSpan()); this.addFieldClass(); })
|
||
|
|
* insertAfterWhatNode {Int} - position to insert default message
|
||
|
|
* (DEFAULT: the field that is being validated)
|
||
|
|
* onlyOnBlur {Boolean} - whether you want it to validate as you type or only on blur
|
||
|
|
* (DEFAULT: false)
|
||
|
|
* wait {Integer} - the time you want it to pause from the last keystroke before it validates (ms)
|
||
|
|
* (DEFAULT: 0)
|
||
|
|
* onlyOnSubmit {Boolean} - whether should be validated only when the form it belongs to is submitted
|
||
|
|
* (DEFAULT: false)
|
||
|
|
*/
|
||
|
|
var LiveValidation = function(element, optionsObj){
|
||
|
|
this.initialize(element, optionsObj);
|
||
|
|
}
|
||
|
|
|
||
|
|
LiveValidation.VERSION = '1.3 standalone';
|
||
|
|
|
||
|
|
/** element types constants ****/
|
||
|
|
|
||
|
|
LiveValidation.TEXTAREA = 1;
|
||
|
|
LiveValidation.TEXT = 2;
|
||
|
|
LiveValidation.PASSWORD = 3;
|
||
|
|
LiveValidation.CHECKBOX = 4;
|
||
|
|
LiveValidation.SELECT = 5;
|
||
|
|
LiveValidation.FILE = 6;
|
||
|
|
|
||
|
|
/****** Static methods *******/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* pass an array of LiveValidation objects and it will validate all of them
|
||
|
|
*
|
||
|
|
* @var validations {Array} - an array of LiveValidation objects
|
||
|
|
* @return {Bool} - true if all passed validation, false if any fail
|
||
|
|
*/
|
||
|
|
LiveValidation.massValidate = function(validations){
|
||
|
|
var returnValue = true;
|
||
|
|
for(var i = 0, len = validations.length; i < len; ++i ){
|
||
|
|
var valid = validations[i].validate();
|
||
|
|
if(returnValue) returnValue = valid;
|
||
|
|
}
|
||
|
|
return returnValue;
|
||
|
|
}
|
||
|
|
|
||
|
|
/****** prototype ******/
|
||
|
|
|
||
|
|
LiveValidation.prototype = {
|
||
|
|
|
||
|
|
validClass: 'LV_valid',
|
||
|
|
invalidClass: 'LV_invalid',
|
||
|
|
messageClass: 'LV_validation_message',
|
||
|
|
validFieldClass: 'LV_valid_field',
|
||
|
|
invalidFieldClass: 'LV_invalid_field',
|
||
|
|
|
||
|
|
/**
|
||
|
|
* initialises all of the properties and events
|
||
|
|
*
|
||
|
|
* @var - Same as constructor above
|
||
|
|
*/
|
||
|
|
initialize: function(element, optionsObj){
|
||
|
|
var self = this;
|
||
|
|
if(!element) throw new Error("LiveValidation::initialize - No element reference or element id has been provided!");
|
||
|
|
this.element = element.nodeName ? element : document.getElementById(element);
|
||
|
|
if(!this.element) throw new Error("LiveValidation::initialize - No element with reference or id of '" + element + "' exists!");
|
||
|
|
// default properties that could not be initialised above
|
||
|
|
this.validations = [];
|
||
|
|
this.elementType = this.getElementType();
|
||
|
|
this.form = this.element.form;
|
||
|
|
// options
|
||
|
|
var options = optionsObj || {};
|
||
|
|
this.validMessage = options.validMessage || ''; // AO3
|
||
|
|
var node = options.insertAfterWhatNode || this.element;
|
||
|
|
this.insertAfterWhatNode = node.nodeType ? node : document.getElementById(node);
|
||
|
|
this.onValid = options.onValid || function(){ this.insertMessage(this.createMessageSpan()); this.addFieldClass(); };
|
||
|
|
this.onInvalid = options.onInvalid || function(){ this.insertMessage(this.createMessageSpan()); this.addFieldClass(); };
|
||
|
|
this.onlyOnBlur = options.onlyOnBlur || false;
|
||
|
|
this.wait = options.wait || 0;
|
||
|
|
this.onlyOnSubmit = options.onlyOnSubmit || false;
|
||
|
|
// add to form if it has been provided
|
||
|
|
if(this.form){
|
||
|
|
this.formObj = LiveValidationForm.getInstance(this.form);
|
||
|
|
this.formObj.addField(this);
|
||
|
|
}
|
||
|
|
// events
|
||
|
|
// collect old events
|
||
|
|
this.oldOnFocus = this.element.onfocus || function(){};
|
||
|
|
this.oldOnBlur = this.element.onblur || function(){};
|
||
|
|
this.oldOnClick = this.element.onclick || function(){};
|
||
|
|
this.oldOnChange = this.element.onchange || function(){};
|
||
|
|
this.oldOnKeyup = this.element.onkeyup || function(){};
|
||
|
|
this.element.onfocus = function(e){ self.doOnFocus(e); return self.oldOnFocus.call(this, e); }
|
||
|
|
if(!this.onlyOnSubmit){
|
||
|
|
switch(this.elementType){
|
||
|
|
case LiveValidation.CHECKBOX:
|
||
|
|
this.element.onclick = function(e){ self.validate(); return self.oldOnClick.call(this, e); }
|
||
|
|
// let it run into the next to add a change event too
|
||
|
|
case LiveValidation.SELECT:
|
||
|
|
case LiveValidation.FILE:
|
||
|
|
this.element.onchange = function(e){ self.validate(); return self.oldOnChange.call(this, e); }
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
if(!this.onlyOnBlur) this.element.onkeyup = function(e){ self.deferValidation(); return self.oldOnKeyup.call(this, e); }
|
||
|
|
this.element.onblur = function(e){ self.doOnBlur(e); return self.oldOnBlur.call(this, e); }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
this.validate();
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* destroys the instance's events (restoring previous ones) and removes it from any LiveValidationForms
|
||
|
|
*/
|
||
|
|
destroy: function(){
|
||
|
|
if(this.formObj){
|
||
|
|
// remove the field from the LiveValidationForm
|
||
|
|
this.formObj.removeField(this);
|
||
|
|
// destroy the LiveValidationForm if no LiveValidation fields left in it
|
||
|
|
this.formObj.destroy();
|
||
|
|
}
|
||
|
|
// remove events - set them back to the previous events
|
||
|
|
this.element.onfocus = this.oldOnFocus;
|
||
|
|
if(!this.onlyOnSubmit){
|
||
|
|
switch(this.elementType){
|
||
|
|
case LiveValidation.CHECKBOX:
|
||
|
|
this.element.onclick = this.oldOnClick;
|
||
|
|
// let it run into the next to add a change event too
|
||
|
|
case LiveValidation.SELECT:
|
||
|
|
case LiveValidation.FILE:
|
||
|
|
this.element.onchange = this.oldOnChange;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
if(!this.onlyOnBlur) this.element.onkeyup = this.oldOnKeyup;
|
||
|
|
this.element.onblur = this.oldOnBlur;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
this.validations = [];
|
||
|
|
this.removeMessageAndFieldClass();
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* adds a validation to perform to a LiveValidation object
|
||
|
|
*
|
||
|
|
* @var validationFunction {Function} - validation function to be used (ie Validate.Presence )
|
||
|
|
* @var validationParamsObj {Object} - parameters for doing the validation, if wanted or necessary
|
||
|
|
* @return {Object} - the LiveValidation object itself so that calls can be chained
|
||
|
|
*/
|
||
|
|
add: function(validationFunction, validationParamsObj){
|
||
|
|
this.validations.push( {type: validationFunction, params: validationParamsObj || {} } );
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* removes a validation from a LiveValidation object - must have exactly the same arguments as used to add it
|
||
|
|
*
|
||
|
|
* @var validationFunction {Function} - validation function to be used (ie Validate.Presence )
|
||
|
|
* @var validationParamsObj {Object} - parameters for doing the validation, if wanted or necessary
|
||
|
|
* @return {Object} - the LiveValidation object itself so that calls can be chained
|
||
|
|
*/
|
||
|
|
remove: function(validationFunction, validationParamsObj){
|
||
|
|
var found = false;
|
||
|
|
for( var i = 0, len = this.validations.length; i < len; i++ ){
|
||
|
|
if( this.validations[i].type == validationFunction ){
|
||
|
|
if (this.validations[i].params == validationParamsObj) {
|
||
|
|
found = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(found) this.validations.splice(i,1);
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* makes the validation wait the alotted time from the last keystroke
|
||
|
|
*/
|
||
|
|
deferValidation: function(e){
|
||
|
|
if(this.wait >= 300) this.removeMessageAndFieldClass();
|
||
|
|
var self = this;
|
||
|
|
if(this.timeout) clearTimeout(self.timeout);
|
||
|
|
this.timeout = setTimeout( function(){ self.validate() }, self.wait);
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* // AO3
|
||
|
|
* sets the focused flag to false when field loses focus and triggers TinyMCE to save content into field
|
||
|
|
*/
|
||
|
|
doOnBlur: function(e){
|
||
|
|
if (typeof(tinyMCE)!="undefined") tinyMCE.triggerSave(); // AO3
|
||
|
|
this.focused = false;
|
||
|
|
this.validate(e);
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* sets the focused flag to true when field gains focus
|
||
|
|
*/
|
||
|
|
doOnFocus: function(e){
|
||
|
|
this.focused = true;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* gets the type of element, to check whether it is compatible
|
||
|
|
*
|
||
|
|
* @var validationFunction {Function} - validation function to be used (ie Validate.Presence )
|
||
|
|
* @var validationParamsObj {Object} - parameters for doing the validation, if wanted or necessary
|
||
|
|
*/
|
||
|
|
getElementType: function(){
|
||
|
|
switch(true){
|
||
|
|
case (this.element.nodeName.toUpperCase() == 'TEXTAREA'):
|
||
|
|
return LiveValidation.TEXTAREA;
|
||
|
|
case (this.element.nodeName.toUpperCase() == 'INPUT' && this.element.type.toUpperCase() == 'TEXT'):
|
||
|
|
return LiveValidation.TEXT;
|
||
|
|
case (this.element.nodeName.toUpperCase() == 'INPUT' && this.element.type.toUpperCase() == 'PASSWORD'):
|
||
|
|
return LiveValidation.PASSWORD;
|
||
|
|
case (this.element.nodeName.toUpperCase() == 'INPUT' && this.element.type.toUpperCase() == 'CHECKBOX'):
|
||
|
|
return LiveValidation.CHECKBOX;
|
||
|
|
case (this.element.nodeName.toUpperCase() == 'INPUT' && this.element.type.toUpperCase() == 'FILE'):
|
||
|
|
return LiveValidation.FILE;
|
||
|
|
case (this.element.nodeName.toUpperCase() == 'SELECT'):
|
||
|
|
return LiveValidation.SELECT;
|
||
|
|
case (this.element.nodeName.toUpperCase() == 'INPUT'):
|
||
|
|
throw new Error('LiveValidation::getElementType - Cannot use LiveValidation on an ' + this.element.type + ' input!');
|
||
|
|
default:
|
||
|
|
throw new Error('LiveValidation::getElementType - Element must be an input, select, or textarea!');
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* loops through all the validations added to the LiveValidation object and checks them one by one
|
||
|
|
*
|
||
|
|
* @var validationFunction {Function} - validation function to be used (ie Validate.Presence )
|
||
|
|
* @var validationParamsObj {Object} - parameters for doing the validation, if wanted or necessary
|
||
|
|
* @return {Boolean} - whether the all the validations passed or if one failed
|
||
|
|
*/
|
||
|
|
doValidations: function(){
|
||
|
|
this.validationFailed = false;
|
||
|
|
for(var i = 0, len = this.validations.length; i < len; ++i){
|
||
|
|
var validation = this.validations[i];
|
||
|
|
switch(validation.type){
|
||
|
|
case Validate.Presence:
|
||
|
|
case Validate.Confirmation:
|
||
|
|
case Validate.Acceptance:
|
||
|
|
this.displayMessageWhenEmpty = true;
|
||
|
|
this.validationFailed = !this.validateElement(validation.type, validation.params);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
this.validationFailed = !this.validateElement(validation.type, validation.params);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if(this.validationFailed) return false;
|
||
|
|
}
|
||
|
|
this.message = this.validMessage;
|
||
|
|
return true;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* performs validation on the element and handles any error (validation or otherwise) it throws up
|
||
|
|
*
|
||
|
|
* @var validationFunction {Function} - validation function to be used (ie Validate.Presence )
|
||
|
|
* @var validationParamsObj {Object} - parameters for doing the validation, if wanted or necessary
|
||
|
|
* @return {Boolean} - whether the validation has passed or failed
|
||
|
|
*/
|
||
|
|
validateElement: function(validationFunction, validationParamsObj){
|
||
|
|
// AO3: we want validations to ignore leading and trailing whitespace, since it will be removed
|
||
|
|
var originalValue = (this.elementType == LiveValidation.SELECT) ? this.element.options[this.element.selectedIndex].value : this.element.value;
|
||
|
|
var value = $j.trim(originalValue);
|
||
|
|
// AO3: we also want newlines to be counted as "\r\n"s, regardless of the OS and browsers' whim;
|
||
|
|
// AO3: so we count any single "\n"s and "\r"s as "\r\n", which is what they'll end up as in the db anyway
|
||
|
|
if(typeof(value)=="string"){
|
||
|
|
value = (value.replace(/\r\n/g,"\n")).replace(/\r|\n/g,"\r\n");
|
||
|
|
}
|
||
|
|
// end AO3
|
||
|
|
if(validationFunction == Validate.Acceptance){
|
||
|
|
if(this.elementType != LiveValidation.CHECKBOX) throw new Error('LiveValidation::validateElement - Element to validate acceptance must be a checkbox!');
|
||
|
|
value = this.element.checked;
|
||
|
|
}
|
||
|
|
var isValid = true;
|
||
|
|
try{
|
||
|
|
validationFunction(value, validationParamsObj);
|
||
|
|
} catch(error) {
|
||
|
|
if(error instanceof Validate.Error){
|
||
|
|
if( value !== '' || (value === '' && this.displayMessageWhenEmpty) ){
|
||
|
|
this.validationFailed = true;
|
||
|
|
this.message = error.message;
|
||
|
|
isValid = false;
|
||
|
|
}
|
||
|
|
}else{
|
||
|
|
throw error;
|
||
|
|
}
|
||
|
|
}finally{
|
||
|
|
return isValid;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* makes it do the all the validations and fires off the onValid or onInvalid callbacks
|
||
|
|
*
|
||
|
|
* @return {Boolean} - whether the all the validations passed or if one failed
|
||
|
|
*/
|
||
|
|
validate: function(){
|
||
|
|
if (this.element.disabled) return true;
|
||
|
|
|
||
|
|
var isValid = this.doValidations();
|
||
|
|
if (isValid) {
|
||
|
|
this.onValid();
|
||
|
|
if (typeof jQuery != "undefined") enableSubmit();
|
||
|
|
return true;
|
||
|
|
} else {
|
||
|
|
this.onInvalid();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* enables the field
|
||
|
|
*
|
||
|
|
* @return {LiveValidation} - the LiveValidation object for chaining
|
||
|
|
*/
|
||
|
|
enable: function(){
|
||
|
|
this.element.disabled = false;
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* disables the field and removes any message and styles associated with the field
|
||
|
|
*
|
||
|
|
* @return {LiveValidation} - the LiveValidation object for chaining
|
||
|
|
*/
|
||
|
|
disable: function(){
|
||
|
|
this.element.disabled = true;
|
||
|
|
this.removeMessageAndFieldClass();
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
|
||
|
|
/** Message insertion methods ****************************
|
||
|
|
*
|
||
|
|
* These are only used in the onValid and onInvalid callback functions and so if you overide the default callbacks,
|
||
|
|
* you must either impliment your own functions to do whatever you want, or call some of these from them if you
|
||
|
|
* want to keep some of the functionality
|
||
|
|
*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* makes a span containg the passed or failed message
|
||
|
|
*
|
||
|
|
* @return {HTMLSpanObject} - a span element with the message in it
|
||
|
|
*/
|
||
|
|
createMessageSpan: function(){
|
||
|
|
var span = document.createElement('span');
|
||
|
|
var textNode = document.createTextNode(this.message);
|
||
|
|
span.appendChild(textNode);
|
||
|
|
span.role = "alert";
|
||
|
|
span.id = this.element.id + "_" + this.messageClass;
|
||
|
|
return span;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* inserts the element containing the message in place of the element that already exists (if it does)
|
||
|
|
*
|
||
|
|
* @var elementToIsert {HTMLElementObject} - an element node to insert
|
||
|
|
*/
|
||
|
|
insertMessage: function(elementToInsert){
|
||
|
|
this.removeMessage();
|
||
|
|
var className = this.validationFailed ? this.invalidClass : this.validClass;
|
||
|
|
elementToInsert.className += ' ' + this.messageClass + ' ' + className;
|
||
|
|
if(this.insertAfterWhatNode.nextSibling){
|
||
|
|
this.insertAfterWhatNode.parentNode.insertBefore(elementToInsert, this.insertAfterWhatNode.nextSibling);
|
||
|
|
} else {
|
||
|
|
this.insertAfterWhatNode.parentNode.appendChild(elementToInsert);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* changes the class of the field based on whether it is valid or not
|
||
|
|
*/
|
||
|
|
addFieldClass: function(){
|
||
|
|
this.removeFieldClass();
|
||
|
|
if(!this.validationFailed){
|
||
|
|
if(this.displayMessageWhenEmpty || this.element.value != ''){
|
||
|
|
this.element.setAttribute("aria-invalid", false);
|
||
|
|
this.element.removeAttribute("aria-describedby");
|
||
|
|
if(this.element.className.indexOf(this.validFieldClass) == -1) this.element.className += ' ' + this.validFieldClass;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
this.element.setAttribute("aria-invalid", true);
|
||
|
|
this.element.setAttribute("aria-describedby", this.element.id + "_" + this.messageClass);
|
||
|
|
if(this.element.className.indexOf(this.invalidFieldClass) == -1) this.element.className += ' ' + this.invalidFieldClass;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* removes the message element if it exists, so that the new message will replace it
|
||
|
|
*/
|
||
|
|
removeMessage: function(){
|
||
|
|
var nextEl;
|
||
|
|
var el = this.insertAfterWhatNode;
|
||
|
|
while(el.nextSibling){
|
||
|
|
if(el.nextSibling.nodeType === 1){
|
||
|
|
nextEl = el.nextSibling;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
el = el.nextSibling;
|
||
|
|
}
|
||
|
|
if(nextEl && nextEl.className.indexOf(this.messageClass) != -1) this.insertAfterWhatNode.parentNode.removeChild(nextEl);
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* removes the class that has been applied to the field to indicte if valid or not
|
||
|
|
*/
|
||
|
|
removeFieldClass: function(){
|
||
|
|
if(this.element.className.indexOf(this.invalidFieldClass) != -1) this.element.className = this.element.className.split(this.invalidFieldClass).join('');
|
||
|
|
if(this.element.className.indexOf(this.validFieldClass) != -1) this.element.className = this.element.className.split(this.validFieldClass).join(' ');
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* removes the message and the field class
|
||
|
|
*/
|
||
|
|
removeMessageAndFieldClass: function(){
|
||
|
|
this.removeMessage();
|
||
|
|
this.removeFieldClass();
|
||
|
|
}
|
||
|
|
|
||
|
|
} // end of LiveValidation class
|
||
|
|
|
||
|
|
/*************************************** LiveValidationForm class ****************************************/
|
||
|
|
/**
|
||
|
|
* This class is used internally by LiveValidation class to associate a LiveValidation field with a form it is icontained in one
|
||
|
|
*
|
||
|
|
* It will therefore not really ever be needed to be used directly by the developer, unless they want to associate a LiveValidation
|
||
|
|
* field with a form that it is not a child of
|
||
|
|
*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* handles validation of LiveValidation fields belonging to this form on its submittal
|
||
|
|
*
|
||
|
|
* @var element {HTMLFormElement} - a dom element reference to the form to turn into a LiveValidationForm
|
||
|
|
*/
|
||
|
|
var LiveValidationForm = function(element){
|
||
|
|
this.initialize(element);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* namespace to hold instances
|
||
|
|
*/
|
||
|
|
LiveValidationForm.instances = {};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* gets the instance of the LiveValidationForm if it has already been made or creates it if it doesnt exist
|
||
|
|
*
|
||
|
|
* @var element {HTMLFormElement} - a dom element reference to a form
|
||
|
|
*/
|
||
|
|
LiveValidationForm.getInstance = function(element){
|
||
|
|
var rand = Math.random() * Math.random();
|
||
|
|
if(!element.id) element.id = 'formId_' + rand.toString().replace(/\./, '') + new Date().valueOf();
|
||
|
|
if(!LiveValidationForm.instances[element.id]) LiveValidationForm.instances[element.id] = new LiveValidationForm(element);
|
||
|
|
return LiveValidationForm.instances[element.id];
|
||
|
|
}
|
||
|
|
|
||
|
|
LiveValidationForm.prototype = {
|
||
|
|
|
||
|
|
/**
|
||
|
|
* constructor for LiveValidationForm - handles validation of LiveValidation fields belonging to this form on its submittal
|
||
|
|
*
|
||
|
|
* @var element {HTMLFormElement} - a dom element reference to the form to turn into a LiveValidationForm
|
||
|
|
*/
|
||
|
|
initialize: function(element){
|
||
|
|
this.name = element.id;
|
||
|
|
this.element = element;
|
||
|
|
this.fields = [];
|
||
|
|
// preserve the old onsubmit event
|
||
|
|
// AO3: tinyMCE save needs to be triggered here so live validation recognises content in the rich text editor
|
||
|
|
this.oldOnSubmit = this.element.onsubmit || function(){};
|
||
|
|
var self = this;
|
||
|
|
this.element.onsubmit = function(e){
|
||
|
|
if (typeof(tinyMCE)!="undefined") tinyMCE.triggerSave(this.fields); // AO3
|
||
|
|
var ret = (LiveValidation.massValidate(self.fields)) ? self.oldOnSubmit.call(this, e || window.event) !== false : false;
|
||
|
|
// AO3: don't freeze the form if the user has clicked on the 'cancel' button -elz, 3/2/09, Enigel 3/7/11
|
||
|
|
var buttonClicked = document.activeElement || this.explicitOriginalTarget;
|
||
|
|
if (buttonClicked.name == 'cancel_button') ret = true;
|
||
|
|
else if (!ret) {
|
||
|
|
scrollToErrorIfFound();
|
||
|
|
enableSubmit();
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* adds a LiveValidation field to the forms fields array
|
||
|
|
*
|
||
|
|
* @var element {LiveValidation} - a LiveValidation object
|
||
|
|
*/
|
||
|
|
addField: function(newField){
|
||
|
|
this.fields.push(newField);
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* removes a LiveValidation field from the forms fields array
|
||
|
|
*
|
||
|
|
* @var victim {LiveValidation} - a LiveValidation object
|
||
|
|
*/
|
||
|
|
removeField: function(victim){
|
||
|
|
var victimless = [];
|
||
|
|
for( var i = 0, len = this.fields.length; i < len; i++){
|
||
|
|
if(this.fields[i] !== victim) victimless.push(this.fields[i]);
|
||
|
|
}
|
||
|
|
this.fields = victimless;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* destroy this instance and its events
|
||
|
|
*
|
||
|
|
* @var force {Boolean} - whether to force the detruction even if there are fields still associated
|
||
|
|
*/
|
||
|
|
destroy: function(force){
|
||
|
|
// only destroy if has no fields and not being forced
|
||
|
|
if (this.fields.length != 0 && !force) return false;
|
||
|
|
// remove events - set back to previous events
|
||
|
|
this.element.onsubmit = this.oldOnSubmit;
|
||
|
|
// remove from the instances namespace
|
||
|
|
LiveValidationForm.instances[this.name] = null;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
}// end of LiveValidationForm prototype
|
||
|
|
|
||
|
|
/*************************************** Validate class ****************************************/
|
||
|
|
/**
|
||
|
|
* This class contains all the methods needed for doing the actual validation itself
|
||
|
|
*
|
||
|
|
* All methods are static so that they can be used outside the context of a form field
|
||
|
|
* as they could be useful for validating stuff anywhere you want really
|
||
|
|
*
|
||
|
|
* All of them will return true if the validation is successful, but will raise a ValidationError if
|
||
|
|
* they fail, so that this can be caught and the message explaining the error can be accessed ( as just
|
||
|
|
* returning false would leave you a bit in the dark as to why it failed )
|
||
|
|
*
|
||
|
|
* Can use validation methods alone and wrap in a try..catch statement yourself if you want to access the failure
|
||
|
|
* message and handle the error, or use the Validate::now method if you just want true or false
|
||
|
|
*/
|
||
|
|
|
||
|
|
var Validate = {
|
||
|
|
|
||
|
|
/**
|
||
|
|
* validates that the field has been filled in
|
||
|
|
*
|
||
|
|
* @var value {mixed} - value to be checked
|
||
|
|
* @var paramsObj {Object} - parameters for this particular validation, see below for details
|
||
|
|
*
|
||
|
|
* paramsObj properties:
|
||
|
|
* failureMessage {String} - the message to show when the field fails validation
|
||
|
|
* (DEFAULT: "Can't be empty!")
|
||
|
|
*/
|
||
|
|
Presence: function(value, paramsObj){
|
||
|
|
var paramsObj = paramsObj || {};
|
||
|
|
var message = paramsObj.failureMessage || "Can't be empty!";
|
||
|
|
if(value === '' || value === null || value === undefined){
|
||
|
|
Validate.fail(message);
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* validates that the value is numeric, does not fall within a given range of numbers
|
||
|
|
*
|
||
|
|
* @var value {mixed} - value to be checked
|
||
|
|
* @var paramsObj {Object} - parameters for this particular validation, see below for details
|
||
|
|
*
|
||
|
|
* paramsObj properties:
|
||
|
|
* notANumberMessage {String} - the message to show when the validation fails when value is not a number
|
||
|
|
* (DEFAULT: "Must be a number!")
|
||
|
|
* notAnIntegerMessage {String} - the message to show when the validation fails when value is not an integer
|
||
|
|
* (DEFAULT: "Must be a number!")
|
||
|
|
* wrongNumberMessage {String} - the message to show when the validation fails when is param is used
|
||
|
|
* (DEFAULT: "Must be {is}!")
|
||
|
|
* tooLowMessage {String} - the message to show when the validation fails when minimum param is used
|
||
|
|
* (DEFAULT: "Must not be less than {minimum}!")
|
||
|
|
* tooHighMessage {String} - the message to show when the validation fails when maximum param is used
|
||
|
|
* (DEFAULT: "Must not be more than {maximum}!")
|
||
|
|
* is {Int} - the length must be this long
|
||
|
|
* minimum {Int} - the minimum length allowed
|
||
|
|
* maximum {Int} - the maximum length allowed
|
||
|
|
* onlyInteger {Boolean} - if true will only allow integers to be valid
|
||
|
|
* (DEFAULT: false)
|
||
|
|
*
|
||
|
|
* NB. can be checked if it is within a range by specifying both a minimum and a maximum
|
||
|
|
* NB. will evaluate numbers represented in scientific form (ie 2e10) correctly as numbers
|
||
|
|
*/
|
||
|
|
Numericality: function(value, paramsObj){
|
||
|
|
var suppliedValue = value;
|
||
|
|
var value = Number(value);
|
||
|
|
var paramsObj = paramsObj || {};
|
||
|
|
var minimum = ((paramsObj.minimum) || (paramsObj.minimum == 0)) ? paramsObj.minimum : null;;
|
||
|
|
var maximum = ((paramsObj.maximum) || (paramsObj.maximum == 0)) ? paramsObj.maximum : null;
|
||
|
|
var is = ((paramsObj.is) || (paramsObj.is == 0)) ? paramsObj.is : null;
|
||
|
|
var notANumberMessage = paramsObj.notANumberMessage || "Must be a number!";
|
||
|
|
var notAnIntegerMessage = paramsObj.notAnIntegerMessage || "Must be an integer!";
|
||
|
|
var wrongNumberMessage = paramsObj.wrongNumberMessage || "Must be " + is + "!";
|
||
|
|
var tooLowMessage = paramsObj.tooLowMessage || "Must not be less than " + minimum + "!";
|
||
|
|
var tooHighMessage = paramsObj.tooHighMessage || "Must not be more than " + maximum + "!";
|
||
|
|
if (!isFinite(value)) Validate.fail(notANumberMessage);
|
||
|
|
if (paramsObj.onlyInteger && (/\.0+$|\.$/.test(String(suppliedValue)) || value != parseInt(value)) ) Validate.fail(notAnIntegerMessage);
|
||
|
|
switch(true){
|
||
|
|
case (is !== null):
|
||
|
|
if( value != Number(is) ) Validate.fail(wrongNumberMessage);
|
||
|
|
break;
|
||
|
|
case (minimum !== null && maximum !== null):
|
||
|
|
Validate.Numericality(value, {tooLowMessage: tooLowMessage, minimum: minimum});
|
||
|
|
Validate.Numericality(value, {tooHighMessage: tooHighMessage, maximum: maximum});
|
||
|
|
break;
|
||
|
|
case (minimum !== null):
|
||
|
|
if( value < Number(minimum) ) Validate.fail(tooLowMessage);
|
||
|
|
break;
|
||
|
|
case (maximum !== null):
|
||
|
|
if( value > Number(maximum) ) Validate.fail(tooHighMessage);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* validates against a RegExp pattern
|
||
|
|
*
|
||
|
|
* @var value {mixed} - value to be checked
|
||
|
|
* @var paramsObj {Object} - parameters for this particular validation, see below for details
|
||
|
|
*
|
||
|
|
* paramsObj properties:
|
||
|
|
* failureMessage {String} - the message to show when the field fails validation
|
||
|
|
* (DEFAULT: "Not valid!")
|
||
|
|
* pattern {RegExp} - the regular expression pattern
|
||
|
|
* (DEFAULT: /./)
|
||
|
|
* negate {Boolean} - if set to true, will validate true if the pattern is not matched
|
||
|
|
* (DEFAULT: false)
|
||
|
|
*
|
||
|
|
* NB. will return true for an empty string, to allow for non-required, empty fields to validate.
|
||
|
|
* If you do not want this to be the case then you must either add a LiveValidation.PRESENCE validation
|
||
|
|
* or build it into the regular expression pattern
|
||
|
|
*/
|
||
|
|
Format: function(value, paramsObj){
|
||
|
|
var value = String(value);
|
||
|
|
var paramsObj = paramsObj || {};
|
||
|
|
var message = paramsObj.failureMessage || "Not valid!";
|
||
|
|
var pattern = paramsObj.pattern || /./;
|
||
|
|
var negate = paramsObj.negate || false;
|
||
|
|
if(!negate && !pattern.test(value)) Validate.fail(message); // normal
|
||
|
|
if(negate && pattern.test(value)) Validate.fail(message); // negated
|
||
|
|
return true;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* validates that the field contains a valid email address
|
||
|
|
*
|
||
|
|
* @var value {mixed} - value to be checked
|
||
|
|
* @var paramsObj {Object} - parameters for this particular validation, see below for details
|
||
|
|
*
|
||
|
|
* paramsObj properties:
|
||
|
|
* failureMessage {String} - the message to show when the field fails validation
|
||
|
|
* (DEFAULT: "Must be a number!" or "Must be an integer!")
|
||
|
|
*/
|
||
|
|
Email: function(value, paramsObj){
|
||
|
|
var paramsObj = paramsObj || {};
|
||
|
|
var message = paramsObj.failureMessage || "Must be a valid email address!";
|
||
|
|
Validate.Format(value, { failureMessage: message, pattern: /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i } );
|
||
|
|
return true;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* validates the length of the value
|
||
|
|
*
|
||
|
|
* @var value {mixed} - value to be checked
|
||
|
|
* @var paramsObj {Object} - parameters for this particular validation, see below for details
|
||
|
|
*
|
||
|
|
* paramsObj properties:
|
||
|
|
* wrongLengthMessage {String} - the message to show when the fails when is param is used
|
||
|
|
* (DEFAULT: "Must be {is} characters long!")
|
||
|
|
* tooShortMessage {String} - the message to show when the fails when minimum param is used
|
||
|
|
* (DEFAULT: "Must not be less than {minimum} characters long!")
|
||
|
|
* tooLongMessage {String} - the message to show when the fails when maximum param is used
|
||
|
|
* (DEFAULT: "Must not be more than {maximum} characters long!")
|
||
|
|
* is {Int} - the length must be this long
|
||
|
|
* minimum {Int} - the minimum length allowed
|
||
|
|
* maximum {Int} - the maximum length allowed
|
||
|
|
*
|
||
|
|
* NB. can be checked if it is within a range by specifying both a minimum and a maximum
|
||
|
|
*/
|
||
|
|
Length: function(value, paramsObj){
|
||
|
|
var value = String(value);
|
||
|
|
var paramsObj = paramsObj || {};
|
||
|
|
var minimum = ((paramsObj.minimum) || (paramsObj.minimum == 0)) ? paramsObj.minimum : null;
|
||
|
|
var maximum = ((paramsObj.maximum) || (paramsObj.maximum == 0)) ? paramsObj.maximum : null;
|
||
|
|
var is = ((paramsObj.is) || (paramsObj.is == 0)) ? paramsObj.is : null;
|
||
|
|
var wrongLengthMessage = paramsObj.wrongLengthMessage || "Must be " + is + " characters long!";
|
||
|
|
var tooShortMessage = paramsObj.tooShortMessage || "Must not be less than " + minimum + " characters long!";
|
||
|
|
var tooLongMessage = paramsObj.tooLongMessage || "Must not be more than " + maximum + " characters long!";
|
||
|
|
switch(true){
|
||
|
|
case (is !== null):
|
||
|
|
if( value.length != Number(is) ) Validate.fail(wrongLengthMessage);
|
||
|
|
break;
|
||
|
|
case (minimum !== null && maximum !== null):
|
||
|
|
Validate.Length(value, {tooShortMessage: tooShortMessage, minimum: minimum});
|
||
|
|
Validate.Length(value, {tooLongMessage: tooLongMessage, maximum: maximum});
|
||
|
|
break;
|
||
|
|
case (minimum !== null):
|
||
|
|
if( value.length < Number(minimum) ) Validate.fail(tooShortMessage);
|
||
|
|
break;
|
||
|
|
case (maximum !== null):
|
||
|
|
if( value.length > Number(maximum) ) Validate.fail(tooLongMessage);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
throw new Error("Validate::Length - Length(s) to validate against must be provided!");
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* validates that the value falls within a given set of values
|
||
|
|
*
|
||
|
|
* @var value {mixed} - value to be checked
|
||
|
|
* @var paramsObj {Object} - parameters for this particular validation, see below for details
|
||
|
|
*
|
||
|
|
* paramsObj properties:
|
||
|
|
* failureMessage {String} - the message to show when the field fails validation
|
||
|
|
* (DEFAULT: "Must be included in the list!")
|
||
|
|
* within {Array} - an array of values that the value should fall in
|
||
|
|
* (DEFAULT: [])
|
||
|
|
* allowNull {Bool} - if true, and a null value is passed in, validates as true
|
||
|
|
* (DEFAULT: false)
|
||
|
|
* partialMatch {Bool} - if true, will not only validate against the whole value to check but also if it is a substring of the value
|
||
|
|
* (DEFAULT: false)
|
||
|
|
* caseSensitive {Bool} - if false will compare strings case insensitively
|
||
|
|
* (DEFAULT: true)
|
||
|
|
* negate {Bool} - if true, will validate that the value is not within the given set of values
|
||
|
|
* (DEFAULT: false)
|
||
|
|
*/
|
||
|
|
Inclusion: function(value, paramsObj){
|
||
|
|
var paramsObj = paramsObj || {};
|
||
|
|
var message = paramsObj.failureMessage || "Must be included in the list!";
|
||
|
|
var caseSensitive = (paramsObj.caseSensitive === false) ? false : true;
|
||
|
|
if(paramsObj.allowNull && value == null) return true;
|
||
|
|
if(!paramsObj.allowNull && value == null) Validate.fail(message);
|
||
|
|
var within = paramsObj.within || [];
|
||
|
|
//if case insensitive, make all strings in the array lowercase, and the value too
|
||
|
|
if(!caseSensitive){
|
||
|
|
var lowerWithin = [];
|
||
|
|
for(var j = 0, length = within.length; j < length; ++j){
|
||
|
|
var item = within[j];
|
||
|
|
if(typeof item == 'string') item = item.toLowerCase();
|
||
|
|
lowerWithin.push(item);
|
||
|
|
}
|
||
|
|
within = lowerWithin;
|
||
|
|
if(typeof value == 'string') value = value.toLowerCase();
|
||
|
|
}
|
||
|
|
var found = false;
|
||
|
|
for(var i = 0, length = within.length; i < length; ++i){
|
||
|
|
if(within[i] == value) found = true;
|
||
|
|
if(paramsObj.partialMatch){
|
||
|
|
if(value.indexOf(within[i]) != -1) found = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if( (!paramsObj.negate && !found) || (paramsObj.negate && found) ) Validate.fail(message);
|
||
|
|
return true;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* validates that the value does not fall within a given set of values
|
||
|
|
*
|
||
|
|
* @var value {mixed} - value to be checked
|
||
|
|
* @var paramsObj {Object} - parameters for this particular validation, see below for details
|
||
|
|
*
|
||
|
|
* paramsObj properties:
|
||
|
|
* failureMessage {String} - the message to show when the field fails validation
|
||
|
|
* (DEFAULT: "Must not be included in the list!")
|
||
|
|
* within {Array} - an array of values that the value should not fall in
|
||
|
|
* (DEFAULT: [])
|
||
|
|
* allowNull {Bool} - if true, and a null value is passed in, validates as true
|
||
|
|
* (DEFAULT: false)
|
||
|
|
* partialMatch {Bool} - if true, will not only validate against the whole value to check but also if it is a substring of the value
|
||
|
|
* (DEFAULT: false)
|
||
|
|
* caseSensitive {Bool} - if false will compare strings case insensitively
|
||
|
|
* (DEFAULT: true)
|
||
|
|
*/
|
||
|
|
Exclusion: function(value, paramsObj){
|
||
|
|
var paramsObj = paramsObj || {};
|
||
|
|
paramsObj.failureMessage = paramsObj.failureMessage || "Must not be included in the list!";
|
||
|
|
paramsObj.negate = true;
|
||
|
|
Validate.Inclusion(value, paramsObj);
|
||
|
|
return true;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* validates that the value matches that in another field
|
||
|
|
*
|
||
|
|
* @var value {mixed} - value to be checked
|
||
|
|
* @var paramsObj {Object} - parameters for this particular validation, see below for details
|
||
|
|
*
|
||
|
|
* paramsObj properties:
|
||
|
|
* failureMessage {String} - the message to show when the field fails validation
|
||
|
|
* (DEFAULT: "Does not match!")
|
||
|
|
* match {String} - id of the field that this one should match
|
||
|
|
*/
|
||
|
|
Confirmation: function(value, paramsObj){
|
||
|
|
if(!paramsObj.match) throw new Error("Validate::Confirmation - Error validating confirmation: Id of element to match must be provided!");
|
||
|
|
var paramsObj = paramsObj || {};
|
||
|
|
var message = paramsObj.failureMessage || "Does not match!";
|
||
|
|
var match = paramsObj.match.nodeName ? paramsObj.match : document.getElementById(paramsObj.match);
|
||
|
|
if(!match) throw new Error("Validate::Confirmation - There is no reference with name of, or element with id of '" + paramsObj.match + "'!");
|
||
|
|
if(value != match.value){
|
||
|
|
Validate.fail(message);
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* validates that the value is true (for use primarily in detemining if a checkbox has been checked)
|
||
|
|
*
|
||
|
|
* @var value {mixed} - value to be checked if true or not (usually a boolean from the checked value of a checkbox)
|
||
|
|
* @var paramsObj {Object} - parameters for this particular validation, see below for details
|
||
|
|
*
|
||
|
|
* paramsObj properties:
|
||
|
|
* failureMessage {String} - the message to show when the field fails validation
|
||
|
|
* (DEFAULT: "Must be accepted!")
|
||
|
|
*/
|
||
|
|
Acceptance: function(value, paramsObj){
|
||
|
|
var paramsObj = paramsObj || {};
|
||
|
|
var message = paramsObj.failureMessage || "Must be accepted!";
|
||
|
|
if(!value){
|
||
|
|
Validate.fail(message);
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* validates against a custom function that returns true or false (or throws a Validate.Error) when passed the value
|
||
|
|
*
|
||
|
|
* @var value {mixed} - value to be checked
|
||
|
|
* @var paramsObj {Object} - parameters for this particular validation, see below for details
|
||
|
|
*
|
||
|
|
* paramsObj properties:
|
||
|
|
* failureMessage {String} - the message to show when the field fails validation
|
||
|
|
* (DEFAULT: "Not valid!")
|
||
|
|
* against {Function} - a function that will take the value and object of arguments and return true or false
|
||
|
|
* (DEFAULT: function(){ return true; })
|
||
|
|
* args {Object} - an object of named arguments that will be passed to the custom function so are accessible through this object within it
|
||
|
|
* (DEFAULT: {})
|
||
|
|
*/
|
||
|
|
Custom: function(value, paramsObj){
|
||
|
|
var paramsObj = paramsObj || {};
|
||
|
|
var against = paramsObj.against || function(){ return true; };
|
||
|
|
var args = paramsObj.args || {};
|
||
|
|
var message = paramsObj.failureMessage || "Not valid!";
|
||
|
|
if(!against(value, args)) Validate.fail(message);
|
||
|
|
return true;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* validates whatever it is you pass in, and handles the validation error for you so it gives a nice true or false reply
|
||
|
|
*
|
||
|
|
* @var validationFunction {Function} - validation function to be used (ie Validation.validatePresence )
|
||
|
|
* @var value {mixed} - value to be checked if true or not (usually a boolean from the checked value of a checkbox)
|
||
|
|
* @var validationParamsObj {Object} - parameters for doing the validation, if wanted or necessary
|
||
|
|
*/
|
||
|
|
now: function(validationFunction, value, validationParamsObj){
|
||
|
|
if(!validationFunction) throw new Error("Validate::now - Validation function must be provided!");
|
||
|
|
var isValid = true;
|
||
|
|
try{
|
||
|
|
validationFunction(value, validationParamsObj || {});
|
||
|
|
} catch(error) {
|
||
|
|
if(error instanceof Validate.Error){
|
||
|
|
isValid = false;
|
||
|
|
}else{
|
||
|
|
throw error;
|
||
|
|
}
|
||
|
|
}finally{
|
||
|
|
return isValid
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* shortcut for failing throwing a validation error
|
||
|
|
*
|
||
|
|
* @var errorMessage {String} - message to display
|
||
|
|
*/
|
||
|
|
fail: function(errorMessage){
|
||
|
|
throw new Validate.Error(errorMessage);
|
||
|
|
},
|
||
|
|
|
||
|
|
Error: function(errorMessage){
|
||
|
|
this.message = errorMessage;
|
||
|
|
this.name = 'ValidationError';
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
function scrollToErrorIfFound() {
|
||
|
|
var errorField = $j(".LV_invalid_field").first();
|
||
|
|
if (errorField.length !== 0) {
|
||
|
|
$j("html, body").animate({
|
||
|
|
scrollTop: errorField.offset().top
|
||
|
|
}, 1000);
|
||
|
|
errorField.focus();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Enable submit button if there are no errors
|
||
|
|
function enableSubmit() {
|
||
|
|
if ($j(".LV_invalid_field").first().length === 0) {
|
||
|
|
$j.rails.enableFormElement($j("input[data-disable-with]"));
|
||
|
|
}
|
||
|
|
}
|