You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Sonarr/NzbDrone.Web/Scripts/MicrosoftMvcValidation.debu...

882 lines
36 KiB

//!----------------------------------------------------------
//! Copyright (C) Microsoft Corporation. All rights reserved.
//!----------------------------------------------------------
//! MicrosoftMvcValidation.js
Type.registerNamespace('Sys.Mvc');
////////////////////////////////////////////////////////////////////////////////
// Sys.Mvc.Validation
Sys.Mvc.$create_Validation = function Sys_Mvc_Validation() { return {}; }
////////////////////////////////////////////////////////////////////////////////
// Sys.Mvc.JsonValidationField
Sys.Mvc.$create_JsonValidationField = function Sys_Mvc_JsonValidationField() { return {}; }
////////////////////////////////////////////////////////////////////////////////
// Sys.Mvc.JsonValidationOptions
Sys.Mvc.$create_JsonValidationOptions = function Sys_Mvc_JsonValidationOptions() { return {}; }
////////////////////////////////////////////////////////////////////////////////
// Sys.Mvc.JsonValidationRule
Sys.Mvc.$create_JsonValidationRule = function Sys_Mvc_JsonValidationRule() { return {}; }
////////////////////////////////////////////////////////////////////////////////
// Sys.Mvc.ValidationContext
Sys.Mvc.$create_ValidationContext = function Sys_Mvc_ValidationContext() { return {}; }
////////////////////////////////////////////////////////////////////////////////
// Sys.Mvc.NumberValidator
Sys.Mvc.NumberValidator = function Sys_Mvc_NumberValidator() {
}
Sys.Mvc.NumberValidator.create = function Sys_Mvc_NumberValidator$create(rule) {
/// <param name="rule" type="Sys.Mvc.JsonValidationRule">
/// </param>
/// <returns type="Sys.Mvc.Validator"></returns>
return Function.createDelegate(new Sys.Mvc.NumberValidator(), new Sys.Mvc.NumberValidator().validate);
}
Sys.Mvc.NumberValidator.prototype = {
validate: function Sys_Mvc_NumberValidator$validate(value, context) {
/// <param name="value" type="String">
/// </param>
/// <param name="context" type="Sys.Mvc.ValidationContext">
/// </param>
/// <returns type="Object"></returns>
if (Sys.Mvc._validationUtil.stringIsNullOrEmpty(value)) {
return true;
}
var n = Number.parseLocale(value);
return (!isNaN(n));
}
}
////////////////////////////////////////////////////////////////////////////////
// Sys.Mvc.FormContext
Sys.Mvc.FormContext = function Sys_Mvc_FormContext(formElement, validationSummaryElement) {
/// <param name="formElement" type="Object" domElement="true">
/// </param>
/// <param name="validationSummaryElement" type="Object" domElement="true">
/// </param>
/// <field name="_validationSummaryErrorCss" type="String" static="true">
/// </field>
/// <field name="_validationSummaryValidCss" type="String" static="true">
/// </field>
/// <field name="_formValidationTag" type="String" static="true">
/// </field>
/// <field name="_onClickHandler" type="Sys.UI.DomEventHandler">
/// </field>
/// <field name="_onSubmitHandler" type="Sys.UI.DomEventHandler">
/// </field>
/// <field name="_errors" type="Array">
/// </field>
/// <field name="_submitButtonClicked" type="Object" domElement="true">
/// </field>
/// <field name="_validationSummaryElement" type="Object" domElement="true">
/// </field>
/// <field name="_validationSummaryULElement" type="Object" domElement="true">
/// </field>
/// <field name="fields" type="Array" elementType="FieldContext">
/// </field>
/// <field name="_formElement" type="Object" domElement="true">
/// </field>
/// <field name="replaceValidationSummary" type="Boolean">
/// </field>
this._errors = [];
this.fields = new Array(0);
this._formElement = formElement;
this._validationSummaryElement = validationSummaryElement;
formElement[Sys.Mvc.FormContext._formValidationTag] = this;
if (validationSummaryElement) {
var ulElements = validationSummaryElement.getElementsByTagName('ul');
if (ulElements.length > 0) {
this._validationSummaryULElement = ulElements[0];
}
}
this._onClickHandler = Function.createDelegate(this, this._form_OnClick);
this._onSubmitHandler = Function.createDelegate(this, this._form_OnSubmit);
}
Sys.Mvc.FormContext._Application_Load = function Sys_Mvc_FormContext$_Application_Load() {
var allFormOptions = window.mvcClientValidationMetadata;
if (allFormOptions) {
while (allFormOptions.length > 0) {
var thisFormOptions = allFormOptions.pop();
Sys.Mvc.FormContext._parseJsonOptions(thisFormOptions);
}
}
}
Sys.Mvc.FormContext._getFormElementsWithName = function Sys_Mvc_FormContext$_getFormElementsWithName(formElement, name) {
/// <param name="formElement" type="Object" domElement="true">
/// </param>
/// <param name="name" type="String">
/// </param>
/// <returns type="Array" elementType="Object" elementDomElement="true"></returns>
var allElementsWithNameInForm = [];
var allElementsWithName = document.getElementsByName(name);
for (var i = 0; i < allElementsWithName.length; i++) {
var thisElement = allElementsWithName[i];
if (Sys.Mvc.FormContext._isElementInHierarchy(formElement, thisElement)) {
Array.add(allElementsWithNameInForm, thisElement);
}
}
return allElementsWithNameInForm;
}
Sys.Mvc.FormContext.getValidationForForm = function Sys_Mvc_FormContext$getValidationForForm(formElement) {
/// <param name="formElement" type="Object" domElement="true">
/// </param>
/// <returns type="Sys.Mvc.FormContext"></returns>
return formElement[Sys.Mvc.FormContext._formValidationTag];
}
Sys.Mvc.FormContext._isElementInHierarchy = function Sys_Mvc_FormContext$_isElementInHierarchy(parent, child) {
/// <param name="parent" type="Object" domElement="true">
/// </param>
/// <param name="child" type="Object" domElement="true">
/// </param>
/// <returns type="Boolean"></returns>
while (child) {
if (parent === child) {
return true;
}
child = child.parentNode;
}
return false;
}
Sys.Mvc.FormContext._parseJsonOptions = function Sys_Mvc_FormContext$_parseJsonOptions(options) {
/// <param name="options" type="Sys.Mvc.JsonValidationOptions">
/// </param>
/// <returns type="Sys.Mvc.FormContext"></returns>
var formElement = $get(options.FormId);
var validationSummaryElement = (!Sys.Mvc._validationUtil.stringIsNullOrEmpty(options.ValidationSummaryId)) ? $get(options.ValidationSummaryId) : null;
var formContext = new Sys.Mvc.FormContext(formElement, validationSummaryElement);
formContext.enableDynamicValidation();
formContext.replaceValidationSummary = options.ReplaceValidationSummary;
for (var i = 0; i < options.Fields.length; i++) {
var field = options.Fields[i];
var fieldElements = Sys.Mvc.FormContext._getFormElementsWithName(formElement, field.FieldName);
var validationMessageElement = (!Sys.Mvc._validationUtil.stringIsNullOrEmpty(field.ValidationMessageId)) ? $get(field.ValidationMessageId) : null;
var fieldContext = new Sys.Mvc.FieldContext(formContext);
Array.addRange(fieldContext.elements, fieldElements);
fieldContext.validationMessageElement = validationMessageElement;
fieldContext.replaceValidationMessageContents = field.ReplaceValidationMessageContents;
for (var j = 0; j < field.ValidationRules.length; j++) {
var rule = field.ValidationRules[j];
var validator = Sys.Mvc.ValidatorRegistry.getValidator(rule);
if (validator) {
var validation = Sys.Mvc.$create_Validation();
validation.fieldErrorMessage = rule.ErrorMessage;
validation.validator = validator;
Array.add(fieldContext.validations, validation);
}
}
fieldContext.enableDynamicValidation();
Array.add(formContext.fields, fieldContext);
}
var registeredValidatorCallbacks = formElement.validationCallbacks;
if (!registeredValidatorCallbacks) {
registeredValidatorCallbacks = [];
formElement.validationCallbacks = registeredValidatorCallbacks;
}
registeredValidatorCallbacks.push(Function.createDelegate(null, function() {
return Sys.Mvc._validationUtil.arrayIsNullOrEmpty(formContext.validate('submit'));
}));
return formContext;
}
Sys.Mvc.FormContext.prototype = {
_onClickHandler: null,
_onSubmitHandler: null,
_submitButtonClicked: null,
_validationSummaryElement: null,
_validationSummaryULElement: null,
_formElement: null,
replaceValidationSummary: false,
addError: function Sys_Mvc_FormContext$addError(message) {
/// <param name="message" type="String">
/// </param>
this.addErrors([ message ]);
},
addErrors: function Sys_Mvc_FormContext$addErrors(messages) {
/// <param name="messages" type="Array" elementType="String">
/// </param>
if (!Sys.Mvc._validationUtil.arrayIsNullOrEmpty(messages)) {
Array.addRange(this._errors, messages);
this._onErrorCountChanged();
}
},
clearErrors: function Sys_Mvc_FormContext$clearErrors() {
Array.clear(this._errors);
this._onErrorCountChanged();
},
_displayError: function Sys_Mvc_FormContext$_displayError() {
if (this._validationSummaryElement) {
if (this._validationSummaryULElement) {
Sys.Mvc._validationUtil.removeAllChildren(this._validationSummaryULElement);
for (var i = 0; i < this._errors.length; i++) {
var liElement = document.createElement('li');
Sys.Mvc._validationUtil.setInnerText(liElement, this._errors[i]);
this._validationSummaryULElement.appendChild(liElement);
}
}
Sys.UI.DomElement.removeCssClass(this._validationSummaryElement, Sys.Mvc.FormContext._validationSummaryValidCss);
Sys.UI.DomElement.addCssClass(this._validationSummaryElement, Sys.Mvc.FormContext._validationSummaryErrorCss);
}
},
_displaySuccess: function Sys_Mvc_FormContext$_displaySuccess() {
var validationSummaryElement = this._validationSummaryElement;
if (validationSummaryElement) {
var validationSummaryULElement = this._validationSummaryULElement;
if (validationSummaryULElement) {
validationSummaryULElement.innerHTML = '';
}
Sys.UI.DomElement.removeCssClass(validationSummaryElement, Sys.Mvc.FormContext._validationSummaryErrorCss);
Sys.UI.DomElement.addCssClass(validationSummaryElement, Sys.Mvc.FormContext._validationSummaryValidCss);
}
},
enableDynamicValidation: function Sys_Mvc_FormContext$enableDynamicValidation() {
Sys.UI.DomEvent.addHandler(this._formElement, 'click', this._onClickHandler);
Sys.UI.DomEvent.addHandler(this._formElement, 'submit', this._onSubmitHandler);
},
_findSubmitButton: function Sys_Mvc_FormContext$_findSubmitButton(element) {
/// <param name="element" type="Object" domElement="true">
/// </param>
/// <returns type="Object" domElement="true"></returns>
if (element.disabled) {
return null;
}
var tagName = element.tagName.toUpperCase();
var inputElement = element;
if (tagName === 'INPUT') {
var type = inputElement.type;
if (type === 'submit' || type === 'image') {
return inputElement;
}
}
else if ((tagName === 'BUTTON') && (inputElement.type === 'submit')) {
return inputElement;
}
return null;
},
_form_OnClick: function Sys_Mvc_FormContext$_form_OnClick(e) {
/// <param name="e" type="Sys.UI.DomEvent">
/// </param>
this._submitButtonClicked = this._findSubmitButton(e.target);
},
_form_OnSubmit: function Sys_Mvc_FormContext$_form_OnSubmit(e) {
/// <param name="e" type="Sys.UI.DomEvent">
/// </param>
var form = e.target;
var submitButton = this._submitButtonClicked;
if (submitButton && submitButton.disableValidation) {
return;
}
var errorMessages = this.validate('submit');
if (!Sys.Mvc._validationUtil.arrayIsNullOrEmpty(errorMessages)) {
e.preventDefault();
}
},
_onErrorCountChanged: function Sys_Mvc_FormContext$_onErrorCountChanged() {
if (!this._errors.length) {
this._displaySuccess();
}
else {
this._displayError();
}
},
validate: function Sys_Mvc_FormContext$validate(eventName) {
/// <param name="eventName" type="String">
/// </param>
/// <returns type="Array" elementType="String"></returns>
var fields = this.fields;
var errors = [];
for (var i = 0; i < fields.length; i++) {
var field = fields[i];
var thisErrors = field.validate(eventName);
if (thisErrors) {
Array.addRange(errors, thisErrors);
}
}
if (this.replaceValidationSummary) {
this.clearErrors();
this.addErrors(errors);
}
return errors;
}
}
////////////////////////////////////////////////////////////////////////////////
// Sys.Mvc.FieldContext
Sys.Mvc.FieldContext = function Sys_Mvc_FieldContext(formContext) {
/// <param name="formContext" type="Sys.Mvc.FormContext">
/// </param>
/// <field name="_hasTextChangedTag" type="String" static="true">
/// </field>
/// <field name="_hasValidationFiredTag" type="String" static="true">
/// </field>
/// <field name="_inputElementErrorCss" type="String" static="true">
/// </field>
/// <field name="_inputElementValidCss" type="String" static="true">
/// </field>
/// <field name="_validationMessageErrorCss" type="String" static="true">
/// </field>
/// <field name="_validationMessageValidCss" type="String" static="true">
/// </field>
/// <field name="_onBlurHandler" type="Sys.UI.DomEventHandler">
/// </field>
/// <field name="_onChangeHandler" type="Sys.UI.DomEventHandler">
/// </field>
/// <field name="_onInputHandler" type="Sys.UI.DomEventHandler">
/// </field>
/// <field name="_onPropertyChangeHandler" type="Sys.UI.DomEventHandler">
/// </field>
/// <field name="_errors" type="Array">
/// </field>
/// <field name="defaultErrorMessage" type="String">
/// </field>
/// <field name="elements" type="Array" elementType="Object" elementDomElement="true">
/// </field>
/// <field name="formContext" type="Sys.Mvc.FormContext">
/// </field>
/// <field name="replaceValidationMessageContents" type="Boolean">
/// </field>
/// <field name="validationMessageElement" type="Object" domElement="true">
/// </field>
/// <field name="validations" type="Array" elementType="Validation">
/// </field>
this._errors = [];
this.elements = new Array(0);
this.validations = new Array(0);
this.formContext = formContext;
this._onBlurHandler = Function.createDelegate(this, this._element_OnBlur);
this._onChangeHandler = Function.createDelegate(this, this._element_OnChange);
this._onInputHandler = Function.createDelegate(this, this._element_OnInput);
this._onPropertyChangeHandler = Function.createDelegate(this, this._element_OnPropertyChange);
}
Sys.Mvc.FieldContext.prototype = {
_onBlurHandler: null,
_onChangeHandler: null,
_onInputHandler: null,
_onPropertyChangeHandler: null,
defaultErrorMessage: null,
formContext: null,
replaceValidationMessageContents: false,
validationMessageElement: null,
addError: function Sys_Mvc_FieldContext$addError(message) {
/// <param name="message" type="String">
/// </param>
this.addErrors([ message ]);
},
addErrors: function Sys_Mvc_FieldContext$addErrors(messages) {
/// <param name="messages" type="Array" elementType="String">
/// </param>
if (!Sys.Mvc._validationUtil.arrayIsNullOrEmpty(messages)) {
Array.addRange(this._errors, messages);
this._onErrorCountChanged();
}
},
clearErrors: function Sys_Mvc_FieldContext$clearErrors() {
Array.clear(this._errors);
this._onErrorCountChanged();
},
_displayError: function Sys_Mvc_FieldContext$_displayError() {
var validationMessageElement = this.validationMessageElement;
if (validationMessageElement) {
if (this.replaceValidationMessageContents) {
Sys.Mvc._validationUtil.setInnerText(validationMessageElement, this._errors[0]);
}
Sys.UI.DomElement.removeCssClass(validationMessageElement, Sys.Mvc.FieldContext._validationMessageValidCss);
Sys.UI.DomElement.addCssClass(validationMessageElement, Sys.Mvc.FieldContext._validationMessageErrorCss);
}
var elements = this.elements;
for (var i = 0; i < elements.length; i++) {
var element = elements[i];
Sys.UI.DomElement.removeCssClass(element, Sys.Mvc.FieldContext._inputElementValidCss);
Sys.UI.DomElement.addCssClass(element, Sys.Mvc.FieldContext._inputElementErrorCss);
}
},
_displaySuccess: function Sys_Mvc_FieldContext$_displaySuccess() {
var validationMessageElement = this.validationMessageElement;
if (validationMessageElement) {
if (this.replaceValidationMessageContents) {
Sys.Mvc._validationUtil.setInnerText(validationMessageElement, '');
}
Sys.UI.DomElement.removeCssClass(validationMessageElement, Sys.Mvc.FieldContext._validationMessageErrorCss);
Sys.UI.DomElement.addCssClass(validationMessageElement, Sys.Mvc.FieldContext._validationMessageValidCss);
}
var elements = this.elements;
for (var i = 0; i < elements.length; i++) {
var element = elements[i];
Sys.UI.DomElement.removeCssClass(element, Sys.Mvc.FieldContext._inputElementErrorCss);
Sys.UI.DomElement.addCssClass(element, Sys.Mvc.FieldContext._inputElementValidCss);
}
},
_element_OnBlur: function Sys_Mvc_FieldContext$_element_OnBlur(e) {
/// <param name="e" type="Sys.UI.DomEvent">
/// </param>
if (e.target[Sys.Mvc.FieldContext._hasTextChangedTag] || e.target[Sys.Mvc.FieldContext._hasValidationFiredTag]) {
this.validate('blur');
}
},
_element_OnChange: function Sys_Mvc_FieldContext$_element_OnChange(e) {
/// <param name="e" type="Sys.UI.DomEvent">
/// </param>
e.target[Sys.Mvc.FieldContext._hasTextChangedTag] = true;
},
_element_OnInput: function Sys_Mvc_FieldContext$_element_OnInput(e) {
/// <param name="e" type="Sys.UI.DomEvent">
/// </param>
e.target[Sys.Mvc.FieldContext._hasTextChangedTag] = true;
if (e.target[Sys.Mvc.FieldContext._hasValidationFiredTag]) {
this.validate('input');
}
},
_element_OnPropertyChange: function Sys_Mvc_FieldContext$_element_OnPropertyChange(e) {
/// <param name="e" type="Sys.UI.DomEvent">
/// </param>
if (e.rawEvent.propertyName === 'value') {
e.target[Sys.Mvc.FieldContext._hasTextChangedTag] = true;
if (e.target[Sys.Mvc.FieldContext._hasValidationFiredTag]) {
this.validate('input');
}
}
},
enableDynamicValidation: function Sys_Mvc_FieldContext$enableDynamicValidation() {
var elements = this.elements;
for (var i = 0; i < elements.length; i++) {
var element = elements[i];
if (Sys.Mvc._validationUtil.elementSupportsEvent(element, 'onpropertychange')) {
var compatMode = document.documentMode;
if (compatMode && compatMode >= 8) {
Sys.UI.DomEvent.addHandler(element, 'propertychange', this._onPropertyChangeHandler);
}
}
else {
Sys.UI.DomEvent.addHandler(element, 'input', this._onInputHandler);
}
Sys.UI.DomEvent.addHandler(element, 'change', this._onChangeHandler);
Sys.UI.DomEvent.addHandler(element, 'blur', this._onBlurHandler);
}
},
_getErrorString: function Sys_Mvc_FieldContext$_getErrorString(validatorReturnValue, fieldErrorMessage) {
/// <param name="validatorReturnValue" type="Object">
/// </param>
/// <param name="fieldErrorMessage" type="String">
/// </param>
/// <returns type="String"></returns>
var fallbackErrorMessage = fieldErrorMessage || this.defaultErrorMessage;
if (Boolean.isInstanceOfType(validatorReturnValue)) {
return (validatorReturnValue) ? null : fallbackErrorMessage;
}
if (String.isInstanceOfType(validatorReturnValue)) {
return ((validatorReturnValue).length) ? validatorReturnValue : fallbackErrorMessage;
}
return null;
},
_getStringValue: function Sys_Mvc_FieldContext$_getStringValue() {
/// <returns type="String"></returns>
var elements = this.elements;
return (elements.length > 0) ? elements[0].value : null;
},
_markValidationFired: function Sys_Mvc_FieldContext$_markValidationFired() {
var elements = this.elements;
for (var i = 0; i < elements.length; i++) {
var element = elements[i];
element[Sys.Mvc.FieldContext._hasValidationFiredTag] = true;
}
},
_onErrorCountChanged: function Sys_Mvc_FieldContext$_onErrorCountChanged() {
if (!this._errors.length) {
this._displaySuccess();
}
else {
this._displayError();
}
},
validate: function Sys_Mvc_FieldContext$validate(eventName) {
/// <param name="eventName" type="String">
/// </param>
/// <returns type="Array" elementType="String"></returns>
var validations = this.validations;
var errors = [];
var value = this._getStringValue();
for (var i = 0; i < validations.length; i++) {
var validation = validations[i];
var context = Sys.Mvc.$create_ValidationContext();
context.eventName = eventName;
context.fieldContext = this;
context.validation = validation;
var retVal = validation.validator(value, context);
var errorMessage = this._getErrorString(retVal, validation.fieldErrorMessage);
if (!Sys.Mvc._validationUtil.stringIsNullOrEmpty(errorMessage)) {
Array.add(errors, errorMessage);
}
}
this._markValidationFired();
this.clearErrors();
this.addErrors(errors);
return errors;
}
}
////////////////////////////////////////////////////////////////////////////////
// Sys.Mvc.RangeValidator
Sys.Mvc.RangeValidator = function Sys_Mvc_RangeValidator(minimum, maximum) {
/// <param name="minimum" type="Number">
/// </param>
/// <param name="maximum" type="Number">
/// </param>
/// <field name="_minimum" type="Number">
/// </field>
/// <field name="_maximum" type="Number">
/// </field>
this._minimum = minimum;
this._maximum = maximum;
}
Sys.Mvc.RangeValidator.create = function Sys_Mvc_RangeValidator$create(rule) {
/// <param name="rule" type="Sys.Mvc.JsonValidationRule">
/// </param>
/// <returns type="Sys.Mvc.Validator"></returns>
var min = rule.ValidationParameters['minimum'];
var max = rule.ValidationParameters['maximum'];
return Function.createDelegate(new Sys.Mvc.RangeValidator(min, max), new Sys.Mvc.RangeValidator(min, max).validate);
}
Sys.Mvc.RangeValidator.prototype = {
_minimum: null,
_maximum: null,
validate: function Sys_Mvc_RangeValidator$validate(value, context) {
/// <param name="value" type="String">
/// </param>
/// <param name="context" type="Sys.Mvc.ValidationContext">
/// </param>
/// <returns type="Object"></returns>
if (Sys.Mvc._validationUtil.stringIsNullOrEmpty(value)) {
return true;
}
var n = Number.parseLocale(value);
return (!isNaN(n) && this._minimum <= n && n <= this._maximum);
}
}
////////////////////////////////////////////////////////////////////////////////
// Sys.Mvc.RegularExpressionValidator
Sys.Mvc.RegularExpressionValidator = function Sys_Mvc_RegularExpressionValidator(pattern) {
/// <param name="pattern" type="String">
/// </param>
/// <field name="_pattern" type="String">
/// </field>
this._pattern = pattern;
}
Sys.Mvc.RegularExpressionValidator.create = function Sys_Mvc_RegularExpressionValidator$create(rule) {
/// <param name="rule" type="Sys.Mvc.JsonValidationRule">
/// </param>
/// <returns type="Sys.Mvc.Validator"></returns>
var pattern = rule.ValidationParameters['pattern'];
return Function.createDelegate(new Sys.Mvc.RegularExpressionValidator(pattern), new Sys.Mvc.RegularExpressionValidator(pattern).validate);
}
Sys.Mvc.RegularExpressionValidator.prototype = {
_pattern: null,
validate: function Sys_Mvc_RegularExpressionValidator$validate(value, context) {
/// <param name="value" type="String">
/// </param>
/// <param name="context" type="Sys.Mvc.ValidationContext">
/// </param>
/// <returns type="Object"></returns>
if (Sys.Mvc._validationUtil.stringIsNullOrEmpty(value)) {
return true;
}
var regExp = new RegExp(this._pattern);
var matches = regExp.exec(value);
return (!Sys.Mvc._validationUtil.arrayIsNullOrEmpty(matches) && matches[0].length === value.length);
}
}
////////////////////////////////////////////////////////////////////////////////
// Sys.Mvc.RequiredValidator
Sys.Mvc.RequiredValidator = function Sys_Mvc_RequiredValidator() {
}
Sys.Mvc.RequiredValidator.create = function Sys_Mvc_RequiredValidator$create(rule) {
/// <param name="rule" type="Sys.Mvc.JsonValidationRule">
/// </param>
/// <returns type="Sys.Mvc.Validator"></returns>
return Function.createDelegate(new Sys.Mvc.RequiredValidator(), new Sys.Mvc.RequiredValidator().validate);
}
Sys.Mvc.RequiredValidator._isRadioInputElement = function Sys_Mvc_RequiredValidator$_isRadioInputElement(element) {
/// <param name="element" type="Object" domElement="true">
/// </param>
/// <returns type="Boolean"></returns>
if (element.tagName.toUpperCase() === 'INPUT') {
var inputType = (element.type).toUpperCase();
if (inputType === 'RADIO') {
return true;
}
}
return false;
}
Sys.Mvc.RequiredValidator._isSelectInputElement = function Sys_Mvc_RequiredValidator$_isSelectInputElement(element) {
/// <param name="element" type="Object" domElement="true">
/// </param>
/// <returns type="Boolean"></returns>
if (element.tagName.toUpperCase() === 'SELECT') {
return true;
}
return false;
}
Sys.Mvc.RequiredValidator._isTextualInputElement = function Sys_Mvc_RequiredValidator$_isTextualInputElement(element) {
/// <param name="element" type="Object" domElement="true">
/// </param>
/// <returns type="Boolean"></returns>
if (element.tagName.toUpperCase() === 'INPUT') {
var inputType = (element.type).toUpperCase();
switch (inputType) {
case 'TEXT':
case 'PASSWORD':
case 'FILE':
return true;
}
}
if (element.tagName.toUpperCase() === 'TEXTAREA') {
return true;
}
return false;
}
Sys.Mvc.RequiredValidator._validateRadioInput = function Sys_Mvc_RequiredValidator$_validateRadioInput(elements) {
/// <param name="elements" type="Array" elementType="Object" elementDomElement="true">
/// </param>
/// <returns type="Object"></returns>
for (var i = 0; i < elements.length; i++) {
var element = elements[i];
if (element.checked) {
return true;
}
}
return false;
}
Sys.Mvc.RequiredValidator._validateSelectInput = function Sys_Mvc_RequiredValidator$_validateSelectInput(optionElements) {
/// <param name="optionElements" type="DOMElementCollection">
/// </param>
/// <returns type="Object"></returns>
for (var i = 0; i < optionElements.length; i++) {
var element = optionElements[i];
if (element.selected) {
if (!Sys.Mvc._validationUtil.stringIsNullOrEmpty(element.value)) {
return true;
}
}
}
return false;
}
Sys.Mvc.RequiredValidator._validateTextualInput = function Sys_Mvc_RequiredValidator$_validateTextualInput(element) {
/// <param name="element" type="Object" domElement="true">
/// </param>
/// <returns type="Object"></returns>
return (!Sys.Mvc._validationUtil.stringIsNullOrEmpty(element.value));
}
Sys.Mvc.RequiredValidator.prototype = {
validate: function Sys_Mvc_RequiredValidator$validate(value, context) {
/// <param name="value" type="String">
/// </param>
/// <param name="context" type="Sys.Mvc.ValidationContext">
/// </param>
/// <returns type="Object"></returns>
var elements = context.fieldContext.elements;
if (!elements.length) {
return true;
}
var sampleElement = elements[0];
if (Sys.Mvc.RequiredValidator._isTextualInputElement(sampleElement)) {
return Sys.Mvc.RequiredValidator._validateTextualInput(sampleElement);
}
if (Sys.Mvc.RequiredValidator._isRadioInputElement(sampleElement)) {
return Sys.Mvc.RequiredValidator._validateRadioInput(elements);
}
if (Sys.Mvc.RequiredValidator._isSelectInputElement(sampleElement)) {
return Sys.Mvc.RequiredValidator._validateSelectInput((sampleElement).options);
}
return true;
}
}
////////////////////////////////////////////////////////////////////////////////
// Sys.Mvc.StringLengthValidator
Sys.Mvc.StringLengthValidator = function Sys_Mvc_StringLengthValidator(minLength, maxLength) {
/// <param name="minLength" type="Number" integer="true">
/// </param>
/// <param name="maxLength" type="Number" integer="true">
/// </param>
/// <field name="_maxLength" type="Number" integer="true">
/// </field>
/// <field name="_minLength" type="Number" integer="true">
/// </field>
this._minLength = minLength;
this._maxLength = maxLength;
}
Sys.Mvc.StringLengthValidator.create = function Sys_Mvc_StringLengthValidator$create(rule) {
/// <param name="rule" type="Sys.Mvc.JsonValidationRule">
/// </param>
/// <returns type="Sys.Mvc.Validator"></returns>
var minLength = rule.ValidationParameters['minimumLength'];
var maxLength = rule.ValidationParameters['maximumLength'];
return Function.createDelegate(new Sys.Mvc.StringLengthValidator(minLength, maxLength), new Sys.Mvc.StringLengthValidator(minLength, maxLength).validate);
}
Sys.Mvc.StringLengthValidator.prototype = {
_maxLength: 0,
_minLength: 0,
validate: function Sys_Mvc_StringLengthValidator$validate(value, context) {
/// <param name="value" type="String">
/// </param>
/// <param name="context" type="Sys.Mvc.ValidationContext">
/// </param>
/// <returns type="Object"></returns>
if (Sys.Mvc._validationUtil.stringIsNullOrEmpty(value)) {
return true;
}
return (this._minLength <= value.length && value.length <= this._maxLength);
}
}
////////////////////////////////////////////////////////////////////////////////
// Sys.Mvc._validationUtil
Sys.Mvc._validationUtil = function Sys_Mvc__validationUtil() {
}
Sys.Mvc._validationUtil.arrayIsNullOrEmpty = function Sys_Mvc__validationUtil$arrayIsNullOrEmpty(array) {
/// <param name="array" type="Array" elementType="Object">
/// </param>
/// <returns type="Boolean"></returns>
return (!array || !array.length);
}
Sys.Mvc._validationUtil.stringIsNullOrEmpty = function Sys_Mvc__validationUtil$stringIsNullOrEmpty(value) {
/// <param name="value" type="String">
/// </param>
/// <returns type="Boolean"></returns>
return (!value || !value.length);
}
Sys.Mvc._validationUtil.elementSupportsEvent = function Sys_Mvc__validationUtil$elementSupportsEvent(element, eventAttributeName) {
/// <param name="element" type="Object" domElement="true">
/// </param>
/// <param name="eventAttributeName" type="String">
/// </param>
/// <returns type="Boolean"></returns>
return (eventAttributeName in element);
}
Sys.Mvc._validationUtil.removeAllChildren = function Sys_Mvc__validationUtil$removeAllChildren(element) {
/// <param name="element" type="Object" domElement="true">
/// </param>
while (element.firstChild) {
element.removeChild(element.firstChild);
}
}
Sys.Mvc._validationUtil.setInnerText = function Sys_Mvc__validationUtil$setInnerText(element, innerText) {
/// <param name="element" type="Object" domElement="true">
/// </param>
/// <param name="innerText" type="String">
/// </param>
var textNode = document.createTextNode(innerText);
Sys.Mvc._validationUtil.removeAllChildren(element);
element.appendChild(textNode);
}
////////////////////////////////////////////////////////////////////////////////
// Sys.Mvc.ValidatorRegistry
Sys.Mvc.ValidatorRegistry = function Sys_Mvc_ValidatorRegistry() {
/// <field name="validators" type="Object" static="true">
/// </field>
}
Sys.Mvc.ValidatorRegistry.getValidator = function Sys_Mvc_ValidatorRegistry$getValidator(rule) {
/// <param name="rule" type="Sys.Mvc.JsonValidationRule">
/// </param>
/// <returns type="Sys.Mvc.Validator"></returns>
var creator = Sys.Mvc.ValidatorRegistry.validators[rule.ValidationType];
return (creator) ? creator(rule) : null;
}
Sys.Mvc.ValidatorRegistry._getDefaultValidators = function Sys_Mvc_ValidatorRegistry$_getDefaultValidators() {
/// <returns type="Object"></returns>
return { required: Function.createDelegate(null, Sys.Mvc.RequiredValidator.create), stringLength: Function.createDelegate(null, Sys.Mvc.StringLengthValidator.create), regularExpression: Function.createDelegate(null, Sys.Mvc.RegularExpressionValidator.create), range: Function.createDelegate(null, Sys.Mvc.RangeValidator.create), number: Function.createDelegate(null, Sys.Mvc.NumberValidator.create) };
}
Sys.Mvc.NumberValidator.registerClass('Sys.Mvc.NumberValidator');
Sys.Mvc.FormContext.registerClass('Sys.Mvc.FormContext');
Sys.Mvc.FieldContext.registerClass('Sys.Mvc.FieldContext');
Sys.Mvc.RangeValidator.registerClass('Sys.Mvc.RangeValidator');
Sys.Mvc.RegularExpressionValidator.registerClass('Sys.Mvc.RegularExpressionValidator');
Sys.Mvc.RequiredValidator.registerClass('Sys.Mvc.RequiredValidator');
Sys.Mvc.StringLengthValidator.registerClass('Sys.Mvc.StringLengthValidator');
Sys.Mvc._validationUtil.registerClass('Sys.Mvc._validationUtil');
Sys.Mvc.ValidatorRegistry.registerClass('Sys.Mvc.ValidatorRegistry');
Sys.Mvc.FormContext._validationSummaryErrorCss = 'validation-summary-errors';
Sys.Mvc.FormContext._validationSummaryValidCss = 'validation-summary-valid';
Sys.Mvc.FormContext._formValidationTag = '__MVC_FormValidation';
Sys.Mvc.FieldContext._hasTextChangedTag = '__MVC_HasTextChanged';
Sys.Mvc.FieldContext._hasValidationFiredTag = '__MVC_HasValidationFired';
Sys.Mvc.FieldContext._inputElementErrorCss = 'input-validation-error';
Sys.Mvc.FieldContext._inputElementValidCss = 'input-validation-valid';
Sys.Mvc.FieldContext._validationMessageErrorCss = 'field-validation-error';
Sys.Mvc.FieldContext._validationMessageValidCss = 'field-validation-valid';
Sys.Mvc.ValidatorRegistry.validators = Sys.Mvc.ValidatorRegistry._getDefaultValidators();
// ---- Do not remove this footer ----
// Generated using Script# v0.5.0.0 (http://projects.nikhilk.net)
// -----------------------------------
// register validation
Sys.Application.add_load(function() {
Sys.Application.remove_load(arguments.callee);
Sys.Mvc.FormContext._Application_Load();
});