(function ($) {
    $.validator.addMethod("jqdatecompare", function (value, element, params) {
       
        if (this.optional(element)) { //No value is always valid use "Required" if a required field.
            return true;
        }

        //load variables from params
        var dateOfCurCol = new Date(value);
        var compareElementId = '#' + String(params.element.id);
        var dateToCompare = new Date($(compareElementId).val());
        var compareOp = String(params.compareop);
       
        switch (compareOp) {
            case "Equals":
                if (dateOfCurCol.getTime() == dateToCompare.getTime()) {
                    return true;
                }
                break;
            case "DoesNotEqual":
                if (dateOfCurCol != dateToCompare) {
                    return true;
                }
                break;
            case "LessThan":
                if (dateOfCurCol < dateToCompare) {
                    return true;
                }
                break;
            case "GreaterThan":
                if (dateOfCurCol > dateToCompare) {
                    return true;
                }
                break;
            case "LessThanEqual":
                if (dateOfCurCol <= dateToCompare) {
                    return true;
                }
                break;
            case "GreaterThanEqual":
                if (dateOfCurCol >= dateToCompare) {
                    return true;
                }
                break;
        }
        return false;
    });

    function getModelPrefix(fieldName) {
        return fieldName.substr(0, fieldName.lastIndexOf(".") + 1);
    }

    function appendModelPrefix(value, prefix) {
        if (value.indexOf("*.") === 0) {
            value = value.replace("*.", prefix);
        }
        return value;
    }

    $.validator.unobtrusive.adapters.add("datecompare", ["columntocompare", "compareop"], function (options) {
        var prefix = getModelPrefix(options.element.name),
            columntocompare = options.params.columntocompare,
            compareop = options.params.compareop,
            fullOtherName = appendModelPrefix(columntocompare, prefix),
            element = $(options.form).find(":input[name=" + fullOtherName + "]")[0];

        options.rules.jqdatecompare = { element: element, compareop: compareop };
        if (options.message) {
            options.messages.jqdatecompare = options.message;
        }
    });

} (jQuery));

(function ($) {
    $.validator.addMethod("jqdatediffcompare", function (value, element, params) {

        if (this.optional(element)) { //No value is always valid use "Required" if a required field.
            return true;
        }

        //load variables from params
        var dateOfCurCol = new Date(value);
        
        var compareElementId = '#' + String(params.element.id);
        var dateToCompare = new Date($(compareElementId).val());
        var diff_date = dateOfCurCol - dateToCompare;
        
        var compareOp = String(params.compareop);
        var maxUnit = parseInt(params.max, 10);

        switch (compareOp) {
            case "Day":
                var num_days = (((diff_date % 31536000000) % 2628000000) / 86400000);
                if (num_days <= maxUnit) 
                {
                    return true;
                }
                break;
            case "Month":
                var num_months = ((diff_date % 31536000000) / 2628000000);
                if (num_months <= maxUnit) 
                {
                    return true;
                }
                break;
            case "Year":
                var num_years = (diff_date / 31536000000);
                if (num_years <= maxUnit) 
                {
                    return true;
                }
                break;
        }
        return false;
    });

    function getModelPrefix(fieldName) {
        return fieldName.substr(0, fieldName.lastIndexOf(".") + 1);
    }

    function appendModelPrefix(value, prefix) {
        if (value.indexOf("*.") === 0) {
            value = value.replace("*.", prefix);
        }
        return value;
    }

    $.validator.unobtrusive.adapters.add("datediffcompare", ["columntocompare", "compareop", "max"], function (options) {
        var prefix = getModelPrefix(options.element.name),
            columntocompare = options.params.columntocompare,
            compareop = options.params.compareop,
            max = options.params.max,
            fullOtherName = appendModelPrefix(columntocompare, prefix),
            element = $(options.form).find(":input[name=" + fullOtherName + "]")[0];

        options.rules.jqdatediffcompare = { element: element, compareop: compareop, max: max };
        if (options.message) {
            options.messages.jqdatediffcompare = options.message;
        }
    });

} (jQuery));
    /**
    * DHTML date validation script. Courtesy of SmartWebby.com (http://www.smartwebby.com/dhtml/)
    */
    // Declaring valid date character, minimum year and maximum year
    var dtCh = "/";
    var minYear = 1900;
    var maxYear = 2100;

    function isInteger(s) {
        var i;
        for (i = 0; i < s.length; i++) {
            // Check that current character is number.
            var c = s.charAt(i);
            if ((c < "0") || (c > "9")) { return false; }
        }
        // All characters are numbers.
        return true;
    }

    function stripCharsInBag(s, bag) {
        var i;
        var returnString = "";
        // Search through string's characters one by one.
        // If character is not in bag, append to returnString.
        for (i = 0; i < s.length; i++) {
            var c = s.charAt(i);
            if (bag.indexOf(c) === -1) { returnString += c; }
        }
        return returnString;
    }

    function daysInFebruary(year) {
        // February has 29 days in any year evenly divisible by four,
        // EXCEPT for centurial years which are not also divisible by 400.
        return (((year % 4 === 0) && ((year % 100 !== 0) || (year % 400 === 0))) ? 29 : 28);
    }
    function DaysArray(n) {
        var i;
        for (i = 1; i <= n; i++) {
            this[i] = 31;
            if (i === 4 || i === 6 || i === 9 || i === 11) { this[i] = 30; }
            if (i === 2) { this[i] = 29; }
        }
        return this;
    }

    function isDate(dtStr) {
        var daysInMonth = DaysArray(12);
        var pos1 = dtStr.indexOf(dtCh);
        var pos2 = dtStr.indexOf(dtCh, pos1 + 1);
        var strMonth = dtStr.substring(0, pos1);
        var strDay = dtStr.substring(pos1 + 1, pos2);
        var strYear = dtStr.substring(pos2 + 1);
        strYr = strYear;
        if (strDay.charAt(0) === "0" && strDay.length > 1) { strDay = strDay.substring(1); }
        if (strMonth.charAt(0) === "0" && strMonth.length > 1) { strMonth = strMonth.substring(1); }
        var i;
        for (i = 1; i <= 3; i++) {
            if (strYr.charAt(0) === "0" && strYr.length > 1) { strYr = strYr.substring(1); }
        }
        month = parseInt(strMonth, 10);
        day = parseInt(strDay, 10);
        year = parseInt(strYr, 10);
        if (pos1 === -1 || pos2 === -1) {
            //alert("The date format should be : mm/dd/yyyy")
            return false;
        }
        if (strMonth.length < 1 || month < 1 || month > 12) {
            //alert("Please enter a valid month")
            return false;
        }
        if (strDay.length < 1 || day < 1 || day > 31 || (month === 2 && day > daysInFebruary(year)) || day > daysInMonth[month]) {
            //alert("Please enter a valid day")
            return false;
        }
        if (strYear.length !== 4 || year === 0 || year < minYear || year > maxYear) {
            //alert("Please enter a valid 4 digit year between "+minYear+" and "+maxYear)
            return false;
        }
        if (dtStr.indexOf(dtCh, pos2 + 1) !== -1 || isInteger(stripCharsInBag(dtStr, dtCh)) === false) {
            //alert("Please enter a valid date")
            return false;
        }
        return true;
    }
(function ($) {
    $.validator.addMethod("jqemail", function (value, element, params) {
        var value = $("#" + element.id).val();
        var returnVal = true;
        if ((value != null) && (value.length > 0)) {
            // require valid email address
            var pattern = new RegExp(/^([a-zA-Z0-9_\-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$/);
            returnVal = pattern.test(value);
        }
        return returnVal;
    });

    function getModelPrefix(fieldName) {
        return fieldName.substr(0, fieldName.lastIndexOf(".") + 1);
    }

    function appendModelPrefix(value, prefix) {
        if (value.indexof("*.") === 0) {
            value = value.replace("*.", prefix);
        }
        return value;
    }

    $.validator.unobtrusive.adapters.add("email", function (options) {
        var prefix = getModelPrefix(options.element.name);

        options.rules.jqemail = options.element;
        if (options.message) {
            options.messages.jqemail = options.message;
        }
    });

} (jQuery));
(function ($) {
    $.validator.addMethod("jqintcompare", function (value, element, params) {

        if (this.optional(element)) { //No value is always valid use "Required" if a required field.
            return true;
        }

        //load variables from params
        var valCurCol = parseInt(value, 10);
        var compareElementId = '#'+String(params.element.id);
        var valToCompare = parseInt($(compareElementId).val(), 10);
        var compareOp = String(params.compareop);

        switch (compareOp) {
            case "Equals":
                if (valCurCol === valToCompare) {
                    return true;
                }
                break;
            case "DoesNotEqual":
                if (valCurCol !== valToCompare) {
                    return true;
                }
                break;
            case "LessThanEqual":
                if (valCurCol <= valToCompare) {
                    return true;
                }
                break;
            case "LessThan":
                if (valCurCol < valToCompare) {
                    return true;
                }
                break;
            case "GreaterThanEqual":
                if (valCurCol >= valToCompare) {
                    return true;
                }
                break;
            case "GreaterThan":
                if (valCurCol > valToCompare) {
                    return true;
                }
                break;
        };
        return false;
    });

    function getModelPrefix(fieldName) {
        return fieldName.substr(0, fieldName.lastIndexOf(".") + 1);
    }

    function appendModelPrefix(value, prefix) {
        if (value.indexOf("*.") === 0) {
            value = value.replace("*.", prefix);
        }
        return value;
    }

    $.validator.unobtrusive.adapters.add("intcompare", ["columntocompare", "compareop"], function (options) {
        var prefix = getModelPrefix(options.element.name),
            columntocompare = options.params.columntocompare,
            compareop = options.params.compareop,
            fullOtherName = appendModelPrefix(columntocompare, prefix),
            element = $(options.form).find(":input[name=" + fullOtherName + "]")[0];

        options.rules.jqintcompare = { element: element, compareop: compareop };
        if (options.message) {
            options.messages.jqintcompare = options.message;
        }
    });

} (jQuery));
(function ($) {
    $.validator.addMethod("jqmaxlength", function (value, element, params) {

        if (this.optional(element)) { //No value is always valid, use "Required" if a required field.
            return true;
        }
        return value.length <= parseInt(params, 10);
    });

    function getModelPrefix(fieldName) {
        return fieldName.substr(0, fieldName.lastIndexOf(".") + 1);
    }

    function appendModelPrefix(value, prefix) {
        if (value.indexof("*.") === 0) {
            value = value.replace("*.", prefix);
        }
        return value;
    }

    $.validator.unobtrusive.adapters.add("maxlength", ["maxlength"], function (options) {
        var prefix = getModelPrefix(options.element.name),
            maxLength = options.params.maxlength;

        options.rules.jqmaxlength = maxLength;
        if (options.message) {
            options.messages.jqmaxlength = options.message;
        }
    });

} (jQuery));
(function ($) {
    $.validator.addMethod("jqmaxvalue", function (value, element, params) {
        if (this.optional(element)) { //No value is always valid, use "Required" if a required field.
            return true;
        }
        return parseInt(value, 10) <= parseInt(params, 10);
    });

    function getModelPrefix(fieldName) {
        return fieldName.substr(0, fieldName.lastIndexOf(".") + 1);
    }
    function appendModelPrefix(value, prefix) {
        if (value.indexof("*.") === 0) {
            value = value.replace("*.", prefix);
        }
        return value;
    }

    $.validator.unobtrusive.adapters.add("maxvalue", ["maxvalue"], function (options) {
        var prefix = getModelPrefix(options.element.name),
            maxValue = options.params.maxvalue;

        options.rules.jqmaxvalue = maxValue;
        if (options.message) {
            options.messages.jqmaxvalue = options.message;
        }
    });
} (jQuery));
(function ($) {
    $.validator.addMethod("jqminlength", function (value, element, params) {
        if (this.optional(element)) { //No value is always valid, use "Required" if a required field.
            return true;
        }
        return value.length >= parseInt(params, 10);
    });

    function getModelPrefix(fieldName) {
        return fieldName.substr(0, fieldName.lastIndexOf(".") + 1);
    }
    function appendModelPrefix(value, prefix) {
        if (value.indexof("*.") === 0) {
            value = value.replace("*.", prefix);
        }
        return value;
    }

    $.validator.unobtrusive.adapters.add("minlength", ["minlength"], function (options) {
        var prefix = getModelPrefix(options.element.name),
            minLength = options.params.minlength;

        options.rules.jqminlength = minLength;
        if (options.message) {
            options.messages.jqminlength = options.message;
        }
    });
} (jQuery));
(function ($) {
    $.validator.addMethod("jqminvalue", function (value, element, params) {
        if (this.optional(element)) { //No value is always valid, use "Required" if a required field.
            return true;
        }
        return parseInt(value, 10) >= parseInt(params, 10);
    });

    function getModelPrefix(fieldName) {
        return fieldName.substr(0, fieldName.lastIndexOf(".") + 1);
    }
    function appendModelPrefix(value, prefix) {
        if (value.indexof("*.") === 0) {
            value = value.replace("*.", prefix);
        }
        return value;
    }

    $.validator.unobtrusive.adapters.add("minvalue", ["minvalue"], function (options) {
        var prefix = getModelPrefix(options.element.name),
            minValue = options.params.minvalue;

        options.rules.jqminvalue = minValue;
        if (options.message) {
            options.messages.jqminvalue = options.message;
        }
    });
} (jQuery));
(function ($) {
    $.validator.addMethod("jqnotequal", function (value, element, params) {
        if (this.optional(element)) { //No value is always valid, use "Required" if a required field.
            return true;
        }

        return value !== String(params);
    });

    $.validator.unobtrusive.adapters.add("notequal", ["notequalstring"], function (options) {
        var notEqualString = options.params.notequalstring;

        options.rules.jqnotequal = notEqualString;
        if (options.message) {
            options.messages.jqnotequal = options.message;
        }
    });

} (jQuery));
(function ($) {
    $.validator.addMethod("jqphoneus", function (value, element, params) {
        var returnVal = true;
        if ((value !== null) && (value.length > 0)) {
            var pattern = new RegExp(/^(?:\([2-9]\d{2}\)\ ?|[2-9]\d{2}(?:\-?|\ ?))[2-9]\d{2}[- ]?\d{4}$/);
            returnVal = pattern.test(value);
        }
        return returnVal;
    });

    $.validator.unobtrusive.adapters.add("phoneus", function (options) {
        options.rules.jqphoneus = options.element;
        if (options.message) {
            options.messages.jqphoneus = options.message;
        }
    });

} (jQuery));
(function ($) {
    $.validator.addMethod("jqssn", function (value, element, params) {
      
        var returnVal = true;
        if ((value !== null) && (value.length > 0)) {
            // require 3-2-4 numeric pattern for ssn
            var pattern = new RegExp(/^\d{3}-\d{2}-\d{4}$/);
            returnVal = pattern.test(value);
        }
        return returnVal;
    });

    $.validator.unobtrusive.adapters.add("ssn", function (options) {
        options.rules.jqssn = options.element;
        if (options.message) {
            options.messages.jqssn = options.message;
        }
    });

} (jQuery));
(function ($) {
    $.validator.addMethod("jqstringcompare", function (value, element, params) {

        if (this.optional(element)) { //No value is always valid use "Required" if a required field.
            return true;
        }

        //load variables from params
        var stringOfCurCol = String(value);
        var compareElementId = '#'+String(params.element.id);
        var stringToCompare = $(compareElementId).val();
        var compareOp = String(params.compareop);

        switch (compareOp) {
            case "EqualsCaseSensitive":
                if (stringOfCurCol === stringToCompare) {
                    return true;
                }
                break;
            case "DoesNotEqualCaseSensitive":
                if (stringOfCurCol !== stringToCompare) {
                    return true;
                }
                break;
            case "EqualsCaseInSensitive":
                if (stringOfCurCol.toLowerCase() === stringToCompare.toLowerCase()) {
                    return true;
                }
                break;
            case "DoesNotEqualCaseInSensitive":
                if (stringOfCurCol.toLowerCase() !== stringToCompare.toLowerCase()) {
                    return true;
                }
                break;
        }
        return false;
    });

    function getModelPrefix(fieldName) {
        return fieldName.substr(0, fieldName.lastIndexOf(".") + 1);
    }

    function appendModelPrefix(value, prefix) {
        if (value.indexOf("*.") === 0) {
            value = value.replace("*.", prefix);
        }
        return value;
    }

    $.validator.unobtrusive.adapters.add("stringcompare", ["columntocompare", "compareop"], function (options) {
        var prefix = getModelPrefix(options.element.name),
            columntocompare = options.params.columntocompare,
            compareop = options.params.compareop,
            fullOtherName = appendModelPrefix(columntocompare, prefix),
            element = $(options.form).find(":input[name=" + fullOtherName + "]")[0];

        options.rules.jqstringcompare = { element: element, compareop: compareop };
        if (options.message) {
            options.messages.jqstringcompare = options.message;
        }
    });

} (jQuery));
(function ($) {
    $.validator.addMethod("jqzipcode", function (value, element, params) {
        var returnVal = true;
        if ((value !== null) && (value.length > 0)) {
            // require 5 numeric min/max chars
            var pattern = new RegExp(/^[0-9]{5}$/);
            returnVal = pattern.test(value);
        }
        return returnVal;
    });

    $.validator.unobtrusive.adapters.add("zipcode", function (options) {
        options.rules.jqzipcode = options.element;
        if (options.message) {
            options.messages.jqzipcode = options.message;
        }
    });

} (jQuery));