source: trunk/htdocs/scripts/atnf-validation.js

function Validator(frm) {
                this.form = frm;
                this.fields = {};
                this.beforeSubmitHandler = null;
                Validator.registerValidator(this);
        }

Validator.validators = [];

OOUtils.extend(Validator, {
        doValidation: function() {
                for (var valInd in Validator.validators) {
                        if (Validator.validators[valInd].form == this) {
                                return Validator.validators[valInd].validate();
                        }
                }
        },
        registerValidator: function(val) {
                val.form.onsubmit = Validator.doValidation;
                Validator.validators.push(val);
        }
});

Validator.prototype = {
        validate: function() {
                for (var fieldName in this.fields) {
                        var field = this.fields[fieldName].field; 
                        for (var valInd in this.fields[fieldName].validators) {
                                if (!this.fields[fieldName].validators[valInd].validate(field)) {
                                        alert(FieldValidator.getFieldName(field) + " requires " + this.fields[fieldName].validators[valInd].requirement);
                                        field.select();
                                        return false;
                                }
                        }
                }
                
                if (this.beforeSubmitHandler) {
                        return this.beforeSubmitHandler(this);
                }
        },
        addFieldValidator: function(field, val) {
                if (!this.fields[field.id]) {
                        this.fields[field.id] = {field: field, validators: []};
                }
                this.fields[field.id].validators.push(val);
        },
        setBeforeSubmitHandler: function(handler) {
                this.beforeSubmitHandler = handler;
        },
        getField: function(fieldObj) {
                
                if (typeof(fieldObj) != "string") {
                        fieldObj = fieldObj.id;
                }
                
                return this.fields[fieldObj];
        },
        getValidator: function(fieldObj, validatorType) {
                for (var validator in fieldObj.validators) {
                        var currentValidator = fieldObj.validators[validator];
                        if (currentValidator instanceof validatorType) {
                                return currentValidator;
                        }
                }
                
                return null;
        }
};

function FieldValidator() { }

OOUtils.extend(FieldValidator, {
        getText: function(node) {
        
                if (node.title) {
                        return node.title;
                }
                
                if (node.data) {
                        return node.data;
                }
                
                var text = "";
                for (var child in node.childNodes) {
                        text += FieldValidator.getText(node.childNodes[child]);
                }
                
                return text;
        },
        getFieldName: function(field) {
                var fieldName = "A field";
                var labels = document.getElementsByTagName("label");
                for (var labelInd in labels) {
                        if (labels[labelInd].htmlFor == field.id) {
                                fieldName = labels[labelInd].title || FieldValidator.getText(labels[labelInd]);
                                break;
                        }
                }
                return fieldName;
        }
});


function REValidator() { }

REValidator.prototype = {
        requirement: "any value",
        re: /.*/,
        validate: function(field) {
                var value = field.value;
                if (!this.re.test(value.trim())) {
                        return false;
                }
                return true;
        }
}

function MandatoryValidator(childValidator) {
        if (childValidator) {
                this.requirement = childValidator.requirement;
                this.childValidator = childValidator;
        }
}

MandatoryValidator.prototype = new REValidator();
OOUtils.extend(MandatoryValidator.prototype, {
        requirement: "a value",
        re: /^.+$/,
        validate: function(field) {
                if (!REValidator.prototype.validate.apply(this, arguments)) {
                        return false;
                }
                if (this.childValidator) {
                        return this.childValidator.validate(field);
                }
                return true;
        }
});

function IntegerValidator() { }

IntegerValidator.prototype = new REValidator();
OOUtils.extend(IntegerValidator.prototype, {
        requirement: "an integer value",
        re: /^\-?\d*$/
});

function RealValidator() { }

RealValidator.prototype = new REValidator();
OOUtils.extend(RealValidator.prototype, {
        requirement: "a real value",
        re: /^\d*(\.\d+)?$/
});

function DateValidator() { 
        this.validatedDate = null;
}

DateValidator.prototype = new FieldValidator();
OOUtils.extend(DateValidator.prototype, {
        validate: function(field) {
                var dateObj;
                
                this.validatedDate = null;
                
                if (field.value.trim() == "") {
                        return true;
                }
                
                try {
                        dateObj = DateValidator.parse(field.value);
                } catch (e) {
                        return false;
                }
                
                this.validatedDate = dateObj;
                return true;
        },
        requirement: "a valid date"
});
        
DateValidator.parse = function(dateStr) {
        var fullDateRE = /(\d+|\D{3,9})[\-\\\/\.](\d+|\D{3,9})[\-\\\/\.](\d+|\D{3,9})/;
        dateStr = dateStr.replace(/\s/g, "");
        if (!re.test(dateStr))
                throw "' " + dateStr + " ' is not a valid date string";
        
        var foundMonth = 0;
        var foundYear = 0;
        var foundDay = 0;
        
        var matches = re.exec(dateStr);
        var monthTextRe = /\D{3,9}/;
        
        for (var x = 1; x <= 3; x++) {
                if (monthTextRe.test(matches[x])) {
                        if (foundMonth != 0) 
                                throw "' " + dateStr + " ' is not a valid date string";
                        
                        matches[x] = this.getMonthFromStr(matches[x]);
                        
                        if (!matches[x])
                                throw "' " + dateStr + " ' is not a valid date string";
                                
                        foundMonth = x;
                } else {
                        var num = new Number(matches[x]);
                        if (num > 31 || num < 1) {
                                if (foundYear != 0)
                                        throw "' " + dateStr + " ' is not a valid date string";
                                        
                                foundYear = x;
                        } else {
                                if (num > 12) {
                                        if (foundDay != 0)
                                                throw "' " + dateStr + " ' is not a valid date string";
                                        
                                        foundDay = x;
                                }
                        }
                }
        }
        
        if (foundYear != 0 && foundMonth != 0) {
                foundDay = (6 - (foundYear + foundMonth));
        } else {
                if (foundYear != 0 && foundDay != 0) {
                        foundMonth = (6 - (foundYear + foundDay));
                } else {
                        if (foundMonth != 0 && foundDay != 0) {
                                foundYear = (6 - (foundMonth + foundDay));
                        }
                }               
        }
        
        if (foundMonth == 0 && foundYear == 0 && foundDay == 0) {
                foundDay = 1; foundMonth = 2; foundYear = 3;
        }
        
        if (foundMonth == 0 || foundYear == 0 || foundDay == 0) {
                if (foundMonth != 0) {
                        switch (foundMonth) {
                                case 3 : throw "' " + dateStr + " ' is not a valid date string";
                                case 2 : foundDay = 1; foundYear = 3; break;
                                case 1 : foundDay = 2; foundYear = 3; break;
                        }
                }
                
                if (foundYear != 0) {
                        switch (foundYear) {
                                case 3 : foundDay = 1; foundMonth = 2; break;
                                case 2 : throw "' " + dateStr + " ' is not a valid date string";
                                case 1 : foundMonth = 2; foundDay = 3; break;
                        }
                }
                
                if (foundDay != 0) {
                        switch (foundDay) {
                                case 3 : foundYear = 1; foundMonth = 2; break;
                                case 2 : throw "' " + dateStr + " ' is not a valid date string";
                                case 1 : foundMonth = 2; foundYear = 3; break;
                        }
                }
        }
        
        var year, month, day;
        
        year = Number(matches[foundYear]);
        month = Number(matches[foundMonth]);
        day = Number(matches[foundDay]);
        
        var date = new Date(year, month - 1, day);
        return date;
}

DateValidator.getMonthFromStr = function(str) {
        var names = ["january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december"];
        
        for (var month in names) {
                if (str.toLowerCase() == names[month] || names[month].indexOf(str.toLowerCase()) == 0) {
                        return new Number(month) + 1;
                }
        }
        
        return false;
}

function TimeValidator() { 
        this.validatedDate = null;
}

TimeValidator.prototype = new FieldValidator();
TimeValidator.prototype.requirement = "a valid time";
TimeValidator.prototype.validate = function(field) {
                var dateObj;
                
                this.validatedDate = null;
                
                if (field.value.trim() == "") {
                        return true;
                }
                
                try {
                        dateObj = TimeValidator.parse(field.value);
                } catch (e) {
                        return false;
                }
                
                this.validatedDate = dateObj;
                return true;
}

TimeValidator.parse = function(timeStr) {
        var re = /^(\d{1,2})(:(\d{2}))?(:(\d{2}))?(AM|PM)?$/i;
        timeStr = timeStr.replace(/\s/g, "");
        
        if (!re.test(timeStr)) {
                throw "'" + timeStr + "' is not a valid time string";
        }
        
        var matches = re.exec(timeStr);
        
        var hours = Number(matches[1]);
        var minutes = 0;
        var seconds = 0;
        var noonRelation = null;
        
        if (matches[2] != null) {
                minutes = Number(matches[3]);
        }
        
        if (matches[4] != null) {
                seconds = Number(matches[5]);
        }
        
        if (matches[6] != null) {
                noonRelation = matches[6];
        }
        
        if (noonRelation != null) {
                if (hours > 12 || hours < 1) {
                        throw "'" + timeStr + "' is not a valid time string";
                }
                
                hours %= 12;
                if (noonRelation.toLowerCase() == "pm") {
                        hours += 12;
                }
        }
        
        if (minutes > 59 || seconds > 59 || hours > 23) {
                throw "'" + timeStr + "' is not a valid time string";
        }
        
        var date = new Date(0);
        date.setSeconds(seconds);
        date.setMinutes(minutes);
        date.setHours(hours);

        return date;
}

function DateTimeValidator() {
        this.validateDate = null;
}