prometheus-net

1
/*
2
* This file has been commented to support Visual Studio Intellisense.
3
* You should not use this file at runtime inside the browser--it is only
4
* intended to be used only for design-time IntelliSense.  Please use the
5
* standard jQuery library for all production use.
6
*
7
* Comment version: 1.17.0
8
*/
9

10
/*
11
* Note: While Microsoft is not the author of this file, Microsoft is
12
* offering you a license subject to the terms of the Microsoft Software
13
* License Terms for Microsoft ASP.NET Model View Controller 3.
14
* Microsoft reserves all other rights. The notices below are provided
15
* for informational purposes only and are not the license terms under
16
* which Microsoft distributed this file.
17
*
18
* jQuery Validation Plugin - v1.17.0 - 12/5/2016
19
* https://github.com/jzaefferer/jquery-validation
20
* Copyright (c) 2013 Jörn Zaefferer; Licensed MIT
21
*
22
*/
23

24
(function($) {
25

26
$.extend($.fn, {
27
	// http://docs.jquery.com/Plugins/Validation/validate
28
	validate: function( options ) {
29
		/// <summary>
30
		/// Validates the selected form. This method sets up event handlers for submit, focus,
31
		/// keyup, blur and click to trigger validation of the entire form or individual
32
		/// elements. Each one can be disabled, see the onxxx options (onsubmit, onfocusout,
33
		/// onkeyup, onclick). focusInvalid focuses elements when submitting a invalid form.
34
		/// </summary>
35
		/// <param name="options" type="Object">
36
		/// A set of key/value pairs that configure the validate. All options are optional.
37
		/// </param>
38

39
		// if nothing is selected, return nothing; can't chain anyway
40
		if (!this.length) {
41
			options && options.debug && window.console && console.warn( "nothing selected, can't validate, returning nothing" );
42
			return;
43
		}
44

45
		// check if a validator for this form was already created
46
		var validator = $.data(this[0], 'validator');
47
		if ( validator ) {
48
			return validator;
49
		}
50
		
51
		validator = new $.validator( options, this[0] );
52
		$.data(this[0], 'validator', validator); 
53
		
54
		if ( validator.settings.onsubmit ) {
55
		
56
			// allow suppresing validation by adding a cancel class to the submit button
57
			this.find("input, button").filter(".cancel").click(function() {
58
				validator.cancelSubmit = true;
59
			});
60
			
61
			// when a submitHandler is used, capture the submitting button
62
			if (validator.settings.submitHandler) {
63
				this.find("input, button").filter(":submit").click(function() {
64
					validator.submitButton = this;
65
				});
66
			}
67
		
68
			// validate the form on submit
69
			this.submit( function( event ) {
70
				if ( validator.settings.debug )
71
					// prevent form submit to be able to see console output
72
					event.preventDefault();
73
					
74
				function handle() {
75
					if ( validator.settings.submitHandler ) {
76
						if (validator.submitButton) {
77
							// insert a hidden input as a replacement for the missing submit button
78
							var hidden = $("<input type='hidden'/>").attr("name", validator.submitButton.name).val(validator.submitButton.value).appendTo(validator.currentForm);
79
						}
80
						validator.settings.submitHandler.call( validator, validator.currentForm );
81
						if (validator.submitButton) {
82
							// and clean up afterwards; thanks to no-block-scope, hidden can be referenced
83
							hidden.remove();
84
						}
85
						return false;
86
					}
87
					return true;
88
				}
89
					
90
				// prevent submit for invalid forms or custom submit handlers
91
				if ( validator.cancelSubmit ) {
92
					validator.cancelSubmit = false;
93
					return handle();
94
				}
95
				if ( validator.form() ) {
96
					if ( validator.pendingRequest ) {
97
						validator.formSubmitted = true;
98
						return false;
99
					}
100
					return handle();
101
				} else {
102
					validator.focusInvalid();
103
					return false;
104
				}
105
			});
106
		}
107
		
108
		return validator;
109
	},
110
	// http://docs.jquery.com/Plugins/Validation/valid
111
	valid: function() {
112
		/// <summary>
113
		/// Checks if the selected form is valid or if all selected elements are valid.
114
		/// validate() needs to be called on the form before checking it using this method.
115
		/// </summary>
116
		/// <returns type="Boolean" />
117

118
        if ( $(this[0]).is('form')) {
119
            return this.validate().form();
120
        } else {
121
            var valid = true;
122
            var validator = $(this[0].form).validate();
123
            this.each(function() {
124
				valid &= validator.element(this);
125
            });
126
            return valid;
127
        }
128
    },
129
	// attributes: space seperated list of attributes to retrieve and remove
130
	removeAttrs: function(attributes) {
131
		/// <summary>
132
		/// Remove the specified attributes from the first matched element and return them.
133
		/// </summary>
134
		/// <param name="attributes" type="String">
135
		/// A space-seperated list of attribute names to remove.
136
		/// </param>
137

138
		var result = {},
139
			$element = this;
140
		$.each(attributes.split(/\s/), function(index, value) {
141
			result[value] = $element.attr(value);
142
			$element.removeAttr(value);
143
		});
144
		return result;
145
	},
146
	// http://docs.jquery.com/Plugins/Validation/rules
147
	rules: function(command, argument) {
148
		/// <summary>
149
		/// Return the validations rules for the first selected element.
150
		/// </summary>
151
		/// <param name="command" type="String">
152
		/// Can be either "add" or "remove".
153
		/// </param>
154
		/// <param name="argument" type="">
155
		/// A list of rules to add or remove.
156
		/// </param>
157

158
		var element = this[0];
159
		
160
		if (command) {
161
			var settings = $.data(element.form, 'validator').settings;
162
			var staticRules = settings.rules;
163
			var existingRules = $.validator.staticRules(element);
164
			switch(command) {
165
			case "add":
166
				$.extend(existingRules, $.validator.normalizeRule(argument));
167
				staticRules[element.name] = existingRules;
168
				if (argument.messages)
169
					settings.messages[element.name] = $.extend( settings.messages[element.name], argument.messages );
170
				break;
171
			case "remove":
172
				if (!argument) {
173
					delete staticRules[element.name];
174
					return existingRules;
175
				}
176
				var filtered = {};
177
				$.each(argument.split(/\s/), function(index, method) {
178
					filtered[method] = existingRules[method];
179
					delete existingRules[method];
180
				});
181
				return filtered;
182
			}
183
		}
184
		
185
		var data = $.validator.normalizeRules(
186
		$.extend(
187
			{},
188
			$.validator.metadataRules(element),
189
			$.validator.classRules(element),
190
			$.validator.attributeRules(element),
191
			$.validator.staticRules(element)
192
		), element);
193
		
194
		// make sure required is at front
195
		if (data.required) {
196
			var param = data.required;
197
			delete data.required;
198
			data = $.extend({required: param}, data);
199
		}
200
		
201
		return data;
202
	}
203
});
204

205
// Custom selectors
206
$.extend($.expr[":"], {
207
	// http://docs.jquery.com/Plugins/Validation/blank
208
	blank: function(a) {return !$.trim("" + a.value);},
209
	// http://docs.jquery.com/Plugins/Validation/filled
210
	filled: function(a) {return !!$.trim("" + a.value);},
211
	// http://docs.jquery.com/Plugins/Validation/unchecked
212
	unchecked: function(a) {return !a.checked;}
213
});
214

215
// constructor for validator
216
$.validator = function( options, form ) {
217
	this.settings = $.extend( true, {}, $.validator.defaults, options );
218
	this.currentForm = form;
219
	this.init();
220
};
221

222
$.validator.format = function(source, params) {
223
	/// <summary>
224
	/// Replaces {n} placeholders with arguments.
225
	/// One or more arguments can be passed, in addition to the string template itself, to insert
226
	/// into the string.
227
	/// </summary>
228
	/// <param name="source" type="String">
229
	/// The string to format.
230
	/// </param>
231
	/// <param name="params" type="String">
232
	/// The first argument to insert, or an array of Strings to insert
233
	/// </param>
234
	/// <returns type="String" />
235

236
	if ( arguments.length == 1 ) 
237
		return function() {
238
			var args = $.makeArray(arguments);
239
			args.unshift(source);
240
			return $.validator.format.apply( this, args );
241
		};
242
	if ( arguments.length > 2 && params.constructor != Array  ) {
243
		params = $.makeArray(arguments).slice(1);
244
	}
245
	if ( params.constructor != Array ) {
246
		params = [ params ];
247
	}
248
	$.each(params, function(i, n) {
249
		source = source.replace(new RegExp("\\{" + i + "\\}", "g"), n);
250
	});
251
	return source;
252
};
253

254
$.extend($.validator, {
255
	
256
	defaults: {
257
		messages: {},
258
		groups: {},
259
		rules: {},
260
		errorClass: "error",
261
		validClass: "valid",
262
		errorElement: "label",
263
		focusInvalid: true,
264
		errorContainer: $( [] ),
265
		errorLabelContainer: $( [] ),
266
		onsubmit: true,
267
		ignore: [],
268
		ignoreTitle: false,
269
		onfocusin: function(element) {
270
			this.lastActive = element;
271
				
272
			// hide error label and remove error class on focus if enabled
273
			if ( this.settings.focusCleanup && !this.blockFocusCleanup ) {
274
				this.settings.unhighlight && this.settings.unhighlight.call( this, element, this.settings.errorClass, this.settings.validClass );
275
				this.addWrapper(this.errorsFor(element)).hide();
276
			}
277
		},
278
		onfocusout: function(element) {
279
			if ( !this.checkable(element) && (element.name in this.submitted || !this.optional(element)) ) {
280
				this.element(element);
281
			}
282
		},
283
		onkeyup: function(element) {
284
			if ( element.name in this.submitted || element == this.lastElement ) {
285
				this.element(element);
286
			}
287
		},
288
		onclick: function(element) {
289
			// click on selects, radiobuttons and checkboxes
290
			if ( element.name in this.submitted )
291
				this.element(element);
292
			// or option elements, check parent select in that case
293
			else if (element.parentNode.name in this.submitted)
294
				this.element(element.parentNode);
295
		},
296
		highlight: function( element, errorClass, validClass ) {
297
			$(element).addClass(errorClass).removeClass(validClass);
298
		},
299
		unhighlight: function( element, errorClass, validClass ) {
300
			$(element).removeClass(errorClass).addClass(validClass);
301
		}
302
	},
303

304
	// http://docs.jquery.com/Plugins/Validation/Validator/setDefaults
305
	setDefaults: function(settings) {
306
		/// <summary>
307
		/// Modify default settings for validation.
308
		/// Accepts everything that Plugins/Validation/validate accepts.
309
		/// </summary>
310
		/// <param name="settings" type="Options">
311
		/// Options to set as default.
312
		/// </param>
313

314
		$.extend( $.validator.defaults, settings );
315
	},
316

317
	messages: {
318
		required: "This field is required.",
319
		remote: "Please fix this field.",
320
		email: "Please enter a valid email address.",
321
		url: "Please enter a valid URL.",
322
		date: "Please enter a valid date.",
323
		dateISO: "Please enter a valid date (ISO).",
324
		number: "Please enter a valid number.",
325
		digits: "Please enter only digits.",
326
		creditcard: "Please enter a valid credit card number.",
327
		equalTo: "Please enter the same value again.",
328
		accept: "Please enter a value with a valid extension.",
329
		maxlength: $.validator.format("Please enter no more than {0} characters."),
330
		minlength: $.validator.format("Please enter at least {0} characters."),
331
		rangelength: $.validator.format("Please enter a value between {0} and {1} characters long."),
332
		range: $.validator.format("Please enter a value between {0} and {1}."),
333
		max: $.validator.format("Please enter a value less than or equal to {0}."),
334
		min: $.validator.format("Please enter a value greater than or equal to {0}.")
335
	},
336
	
337
	autoCreateRanges: false,
338
	
339
	prototype: {
340
		
341
		init: function() {
342
			this.labelContainer = $(this.settings.errorLabelContainer);
343
			this.errorContext = this.labelContainer.length && this.labelContainer || $(this.currentForm);
344
			this.containers = $(this.settings.errorContainer).add( this.settings.errorLabelContainer );
345
			this.submitted = {};
346
			this.valueCache = {};
347
			this.pendingRequest = 0;
348
			this.pending = {};
349
			this.invalid = {};
350
			this.reset();
351
			
352
			var groups = (this.groups = {});
353
			$.each(this.settings.groups, function(key, value) {
354
				$.each(value.split(/\s/), function(index, name) {
355
					groups[name] = key;
356
				});
357
			});
358
			var rules = this.settings.rules;
359
			$.each(rules, function(key, value) {
360
				rules[key] = $.validator.normalizeRule(value);
361
			});
362
			
363
			function delegate(event) {
364
				var validator = $.data(this[0].form, "validator"),
365
					eventType = "on" + event.type.replace(/^validate/, "");
366
				validator.settings[eventType] && validator.settings[eventType].call(validator, this[0] );
367
			}
368
			$(this.currentForm)
369
				.validateDelegate(":text, :password, :file, select, textarea", "focusin focusout keyup", delegate)
370
				.validateDelegate(":radio, :checkbox, select, option", "click", delegate);
371

372
			if (this.settings.invalidHandler)
373
				$(this.currentForm).bind("invalid-form.validate", this.settings.invalidHandler);
374
		},
375

376
		// http://docs.jquery.com/Plugins/Validation/Validator/form
377
		form: function() {
378
			/// <summary>
379
			/// Validates the form, returns true if it is valid, false otherwise.
380
			/// This behaves as a normal submit event, but returns the result.
381
			/// </summary>
382
			/// <returns type="Boolean" />
383

384
			this.checkForm();
385
			$.extend(this.submitted, this.errorMap);
386
			this.invalid = $.extend({}, this.errorMap);
387
			if (!this.valid())
388
				$(this.currentForm).triggerHandler("invalid-form", [this]);
389
			this.showErrors();
390
			return this.valid();
391
		},
392
		
393
		checkForm: function() {
394
			this.prepareForm();
395
			for ( var i = 0, elements = (this.currentElements = this.elements()); elements[i]; i++ ) {
396
				this.check( elements[i] );
397
			}
398
			return this.valid(); 
399
		},
400
		
401
		// http://docs.jquery.com/Plugins/Validation/Validator/element
402
		element: function( element ) {
403
			/// <summary>
404
			/// Validates a single element, returns true if it is valid, false otherwise.
405
			/// This behaves as validation on blur or keyup, but returns the result.
406
			/// </summary>
407
			/// <param name="element" type="Selector">
408
			/// An element to validate, must be inside the validated form.
409
			/// </param>
410
			/// <returns type="Boolean" />
411

412
			element = this.clean( element );
413
			this.lastElement = element;
414
			this.prepareElement( element );
415
			this.currentElements = $(element);
416
			var result = this.check( element );
417
			if ( result ) {
418
				delete this.invalid[element.name];
419
			} else {
420
				this.invalid[element.name] = true;
421
			}
422
			if ( !this.numberOfInvalids() ) {
423
				// Hide error containers on last error
424
				this.toHide = this.toHide.add( this.containers );
425
			}
426
			this.showErrors();
427
			return result;
428
		},
429

430
		// http://docs.jquery.com/Plugins/Validation/Validator/showErrors
431
		showErrors: function(errors) {
432
			/// <summary>
433
			/// Show the specified messages.
434
			/// Keys have to refer to the names of elements, values are displayed for those elements, using the configured error placement.
435
			/// </summary>
436
			/// <param name="errors" type="Object">
437
			/// One or more key/value pairs of input names and messages.
438
			/// </param>
439

440
			if(errors) {
441
				// add items to error list and map
442
				$.extend( this.errorMap, errors );
443
				this.errorList = [];
444
				for ( var name in errors ) {
445
					this.errorList.push({
446
						message: errors[name],
447
						element: this.findByName(name)[0]
448
					});
449
				}
450
				// remove items from success list
451
				this.successList = $.grep( this.successList, function(element) {
452
					return !(element.name in errors);
453
				});
454
			}
455
			this.settings.showErrors
456
				? this.settings.showErrors.call( this, this.errorMap, this.errorList )
457
				: this.defaultShowErrors();
458
		},
459
		
460
		// http://docs.jquery.com/Plugins/Validation/Validator/resetForm
461
		resetForm: function() {
462
			/// <summary>
463
			/// Resets the controlled form.
464
			/// Resets input fields to their original value (requires form plugin), removes classes
465
			/// indicating invalid elements and hides error messages.
466
			/// </summary>
467

468
			if ( $.fn.resetForm )
469
				$( this.currentForm ).resetForm();
470
			this.submitted = {};
471
			this.prepareForm();
472
			this.hideErrors();
473
			this.elements().removeClass( this.settings.errorClass );
474
		},
475
		
476
		numberOfInvalids: function() {
477
			/// <summary>
478
			/// Returns the number of invalid fields.
479
			/// This depends on the internal validator state. It covers all fields only after
480
			/// validating the complete form (on submit or via $("form").valid()). After validating
481
			/// a single element, only that element is counted. Most useful in combination with the
482
			/// invalidHandler-option.
483
			/// </summary>
484
			/// <returns type="Number" />
485

486
			return this.objectLength(this.invalid);
487
		},
488
		
489
		objectLength: function( obj ) {
490
			var count = 0;
491
			for ( var i in obj )
492
				count++;
493
			return count;
494
		},
495
		
496
		hideErrors: function() {
497
			this.addWrapper( this.toHide ).hide();
498
		},
499
		
500
		valid: function() {
501
			return this.size() == 0;
502
		},
503
		
504
		size: function() {
505
			return this.errorList.length;
506
		},
507
		
508
		focusInvalid: function() {
509
			if( this.settings.focusInvalid ) {
510
				try {
511
					$(this.findLastActive() || this.errorList.length && this.errorList[0].element || [])
512
					.filter(":visible")
513
					.focus()
514
					// manually trigger focusin event; without it, focusin handler isn't called, findLastActive won't have anything to find
515
					.trigger("focusin");
516
				} catch(e) {
517
					// ignore IE throwing errors when focusing hidden elements
518
				}
519
			}
520
		},
521
		
522
		findLastActive: function() {
523
			var lastActive = this.lastActive;
524
			return lastActive && $.grep(this.errorList, function(n) {
525
				return n.element.name == lastActive.name;
526
			}).length == 1 && lastActive;
527
		},
528
		
529
		elements: function() {
530
			var validator = this,
531
				rulesCache = {};
532
			
533
			// select all valid inputs inside the form (no submit or reset buttons)
534
			// workaround $Query([]).add until http://dev.jquery.com/ticket/2114 is solved
535
			return $([]).add(this.currentForm.elements)
536
			.filter(":input")
537
			.not(":submit, :reset, :image, [disabled]")
538
			.not( this.settings.ignore )
539
			.filter(function() {
540
				!this.name && validator.settings.debug && window.console && console.error( "%o has no name assigned", this);
541
			
542
				// select only the first element for each name, and only those with rules specified
543
				if ( this.name in rulesCache || !validator.objectLength($(this).rules()) )
544
					return false;
545
				
546
				rulesCache[this.name] = true;
547
				return true;
548
			});
549
		},
550
		
551
		clean: function( selector ) {
552
			return $( selector )[0];
553
		},
554
		
555
		errors: function() {
556
			return $( this.settings.errorElement + "." + this.settings.errorClass, this.errorContext );
557
		},
558
		
559
		reset: function() {
560
			this.successList = [];
561
			this.errorList = [];
562
			this.errorMap = {};
563
			this.toShow = $([]);
564
			this.toHide = $([]);
565
			this.currentElements = $([]);
566
		},
567
		
568
		prepareForm: function() {
569
			this.reset();
570
			this.toHide = this.errors().add( this.containers );
571
		},
572
		
573
		prepareElement: function( element ) {
574
			this.reset();
575
			this.toHide = this.errorsFor(element);
576
		},
577
	
578
		check: function( element ) {
579
			element = this.clean( element );
580
			
581
			// if radio/checkbox, validate first element in group instead
582
			if (this.checkable(element)) {
583
			    element = this.findByName(element.name).not(this.settings.ignore)[0];
584
			}
585
			
586
			var rules = $(element).rules();
587
			var dependencyMismatch = false;
588
			for (var method in rules) {
589
				var rule = { method: method, parameters: rules[method] };
590
				try {
591
					var result = $.validator.methods[method].call( this, element.value.replace(/\r/g, ""), element, rule.parameters );
592
					
593
					// if a method indicates that the field is optional and therefore valid,
594
					// don't mark it as valid when there are no other rules
595
					if ( result == "dependency-mismatch" ) {
596
						dependencyMismatch = true;
597
						continue;
598
					}
599
					dependencyMismatch = false;
600
					
601
					if ( result == "pending" ) {
602
						this.toHide = this.toHide.not( this.errorsFor(element) );
603
						return;
604
					}
605
					
606
					if( !result ) {
607
						this.formatAndAdd( element, rule );
608
						return false;
609
					}
610
				} catch(e) {
611
					this.settings.debug && window.console && console.log("exception occured when checking element " + element.id
612
						 + ", check the '" + rule.method + "' method", e);
613
					throw e;
614
				}
615
			}
616
			if (dependencyMismatch)
617
				return;
618
			if ( this.objectLength(rules) )
619
				this.successList.push(element);
620
			return true;
621
		},
622
		
623
		// return the custom message for the given element and validation method
624
		// specified in the element's "messages" metadata
625
		customMetaMessage: function(element, method) {
626
			if (!$.metadata)
627
				return;
628
			
629
			var meta = this.settings.meta
630
				? $(element).metadata()[this.settings.meta]
631
				: $(element).metadata();
632
			
633
			return meta && meta.messages && meta.messages[method];
634
		},
635
		
636
		// return the custom message for the given element name and validation method
637
		customMessage: function( name, method ) {
638
			var m = this.settings.messages[name];
639
			return m && (m.constructor == String
640
				? m
641
				: m[method]);
642
		},
643
		
644
		// return the first defined argument, allowing empty strings
645
		findDefined: function() {
646
			for(var i = 0; i < arguments.length; i++) {
647
				if (arguments[i] !== undefined)
648
					return arguments[i];
649
			}
650
			return undefined;
651
		},
652
		
653
		defaultMessage: function( element, method) {
654
			return this.findDefined(
655
				this.customMessage( element.name, method ),
656
				this.customMetaMessage( element, method ),
657
				// title is never undefined, so handle empty string as undefined
658
				!this.settings.ignoreTitle && element.title || undefined,
659
				$.validator.messages[method],
660
				"<strong>Warning: No message defined for " + element.name + "</strong>"
661
			);
662
		},
663
		
664
		formatAndAdd: function( element, rule ) {
665
			var message = this.defaultMessage( element, rule.method ),
666
				theregex = /\$?\{(\d+)\}/g;
667
			if ( typeof message == "function" ) {
668
				message = message.call(this, rule.parameters, element);
669
			} else if (theregex.test(message)) {
670
				message = jQuery.format(message.replace(theregex, '{$1}'), rule.parameters);
671
			}			
672
			this.errorList.push({
673
				message: message,
674
				element: element
675
			});
676
			
677
			this.errorMap[element.name] = message;
678
			this.submitted[element.name] = message;
679
		},
680
		
681
		addWrapper: function(toToggle) {
682
			if ( this.settings.wrapper )
683
				toToggle = toToggle.add( toToggle.parent( this.settings.wrapper ) );
684
			return toToggle;
685
		},
686
		
687
		defaultShowErrors: function() {
688
			for ( var i = 0; this.errorList[i]; i++ ) {
689
				var error = this.errorList[i];
690
				this.settings.highlight && this.settings.highlight.call( this, error.element, this.settings.errorClass, this.settings.validClass );
691
				this.showLabel( error.element, error.message );
692
			}
693
			if( this.errorList.length ) {
694
				this.toShow = this.toShow.add( this.containers );
695
			}
696
			if (this.settings.success) {
697
				for ( var i = 0; this.successList[i]; i++ ) {
698
					this.showLabel( this.successList[i] );
699
				}
700
			}
701
			if (this.settings.unhighlight) {
702
				for ( var i = 0, elements = this.validElements(); elements[i]; i++ ) {
703
					this.settings.unhighlight.call( this, elements[i], this.settings.errorClass, this.settings.validClass );
704
				}
705
			}
706
			this.toHide = this.toHide.not( this.toShow );
707
			this.hideErrors();
708
			this.addWrapper( this.toShow ).show();
709
		},
710
		
711
		validElements: function() {
712
			return this.currentElements.not(this.invalidElements());
713
		},
714
		
715
		invalidElements: function() {
716
			return $(this.errorList).map(function() {
717
				return this.element;
718
			});
719
		},
720
		
721
		showLabel: function(element, message) {
722
			var label = this.errorsFor( element );
723
			if ( label.length ) {
724
				// refresh error/success class
725
				label.removeClass().addClass( this.settings.errorClass );
726
			
727
				// check if we have a generated label, replace the message then
728
				label.attr("generated") && label.html(message);
729
			} else {
730
				// create label
731
				label = $("<" + this.settings.errorElement + "/>")
732
					.attr({"for":  this.idOrName(element), generated: true})
733
					.addClass(this.settings.errorClass)
734
					.html(message || "");
735
				if ( this.settings.wrapper ) {
736
					// make sure the element is visible, even in IE
737
					// actually showing the wrapped element is handled elsewhere
738
					label = label.hide().show().wrap("<" + this.settings.wrapper + "/>").parent();
739
				}
740
				if ( !this.labelContainer.append(label).length )
741
					this.settings.errorPlacement
742
						? this.settings.errorPlacement(label, $(element) )
743
						: label.insertAfter(element);
744
			}
745
			if ( !message && this.settings.success ) {
746
				label.text("");
747
				typeof this.settings.success == "string"
748
					? label.addClass( this.settings.success )
749
					: this.settings.success( label );
750
			}
751
			this.toShow = this.toShow.add(label);
752
		},
753
		
754
		errorsFor: function(element) {
755
			var name = this.idOrName(element);
756
    		return this.errors().filter(function() {
757
				return $(this).attr('for') == name;
758
			});
759
		},
760
		
761
		idOrName: function(element) {
762
			return this.groups[element.name] || (this.checkable(element) ? element.name : element.id || element.name);
763
		},
764

765
		checkable: function( element ) {
766
			return /radio|checkbox/i.test(element.type);
767
		},
768
		
769
		findByName: function( name ) {
770
			// select by name and filter by form for performance over form.find("[name=...]")
771
			var form = this.currentForm;
772
			return $(document.getElementsByName(name)).map(function(index, element) {
773
				return element.form == form && element.name == name && element  || null;
774
			});
775
		},
776
		
777
		getLength: function(value, element) {
778
			switch( element.nodeName.toLowerCase() ) {
779
			case 'select':
780
				return $("option:selected", element).length;
781
			case 'input':
782
				if( this.checkable( element) )
783
					return this.findByName(element.name).filter(':checked').length;
784
			}
785
			return value.length;
786
		},
787
	
788
		depend: function(param, element) {
789
			return this.dependTypes[typeof param]
790
				? this.dependTypes[typeof param](param, element)
791
				: true;
792
		},
793
	
794
		dependTypes: {
795
			"boolean": function(param, element) {
796
				return param;
797
			},
798
			"string": function(param, element) {
799
				return !!$(param, element.form).length;
800
			},
801
			"function": function(param, element) {
802
				return param(element);
803
			}
804
		},
805
		
806
		optional: function(element) {
807
			return !$.validator.methods.required.call(this, $.trim(element.value), element) && "dependency-mismatch";
808
		},
809
		
810
		startRequest: function(element) {
811
			if (!this.pending[element.name]) {
812
				this.pendingRequest++;
813
				this.pending[element.name] = true;
814
			}
815
		},
816
		
817
		stopRequest: function(element, valid) {
818
			this.pendingRequest--;
819
			// sometimes synchronization fails, make sure pendingRequest is never < 0
820
			if (this.pendingRequest < 0)
821
				this.pendingRequest = 0;
822
			delete this.pending[element.name];
823
			if ( valid && this.pendingRequest == 0 && this.formSubmitted && this.form() ) {
824
				$(this.currentForm).submit();
825
				this.formSubmitted = false;
826
			} else if (!valid && this.pendingRequest == 0 && this.formSubmitted) {
827
				$(this.currentForm).triggerHandler("invalid-form", [this]);
828
				this.formSubmitted = false;
829
			}
830
		},
831
		
832
		previousValue: function(element) {
833
			return $.data(element, "previousValue") || $.data(element, "previousValue", {
834
				old: null,
835
				valid: true,
836
				message: this.defaultMessage( element, "remote" )
837
			});
838
		}
839
		
840
	},
841
	
842
	classRuleSettings: {
843
		required: {required: true},
844
		email: {email: true},
845
		url: {url: true},
846
		date: {date: true},
847
		dateISO: {dateISO: true},
848
		dateDE: {dateDE: true},
849
		number: {number: true},
850
		numberDE: {numberDE: true},
851
		digits: {digits: true},
852
		creditcard: {creditcard: true}
853
	},
854
	
855
	addClassRules: function(className, rules) {
856
		/// <summary>
857
		/// Add a compound class method - useful to refactor common combinations of rules into a single
858
		/// class.
859
		/// </summary>
860
		/// <param name="name" type="String">
861
		/// The name of the class rule to add
862
		/// </param>
863
		/// <param name="rules" type="Options">
864
		/// The compound rules
865
		/// </param>
866

867
		className.constructor == String ?
868
			this.classRuleSettings[className] = rules :
869
			$.extend(this.classRuleSettings, className);
870
	},
871
	
872
	classRules: function(element) {
873
		var rules = {};
874
		var classes = $(element).attr('class');
875
		classes && $.each(classes.split(' '), function() {
876
			if (this in $.validator.classRuleSettings) {
877
				$.extend(rules, $.validator.classRuleSettings[this]);
878
			}
879
		});
880
		return rules;
881
	},
882
	
883
	attributeRules: function(element) {
884
		var rules = {};
885
		var $element = $(element);
886

887
		for (var method in $.validator.methods) {
888
			var value = $element.attr(method);
889
			if (value) {
890
				rules[method] = value;
891
			}
892
		}
893
		
894
		// maxlength may be returned as -1, 2147483647 (IE) and 524288 (safari) for text inputs
895
		if (rules.maxlength && /-1|2147483647|524288/.test(rules.maxlength)) {
896
			delete rules.maxlength;
897
		}
898
		
899
		return rules;
900
	},
901
	
902
	metadataRules: function(element) {
903
		if (!$.metadata) return {};
904
		
905
		var meta = $.data(element.form, 'validator').settings.meta;
906
		return meta ?
907
			$(element).metadata()[meta] :
908
			$(element).metadata();
909
	},
910
	
911
	staticRules: function(element) {
912
		var rules = {};
913
		var validator = $.data(element.form, 'validator');
914
		if (validator.settings.rules) {
915
			rules = $.validator.normalizeRule(validator.settings.rules[element.name]) || {};
916
		}
917
		return rules;
918
	},
919
	
920
	normalizeRules: function(rules, element) {
921
		// handle dependency check
922
		$.each(rules, function(prop, val) {
923
			// ignore rule when param is explicitly false, eg. required:false
924
			if (val === false) {
925
				delete rules[prop];
926
				return;
927
			}
928
			if (val.param || val.depends) {
929
				var keepRule = true;
930
				switch (typeof val.depends) {
931
					case "string":
932
						keepRule = !!$(val.depends, element.form).length;
933
						break;
934
					case "function":
935
						keepRule = val.depends.call(element, element);
936
						break;
937
				}
938
				if (keepRule) {
939
					rules[prop] = val.param !== undefined ? val.param : true;
940
				} else {
941
					delete rules[prop];
942
				}
943
			}
944
		});
945
		
946
		// evaluate parameters
947
		$.each(rules, function(rule, parameter) {
948
			rules[rule] = $.isFunction(parameter) ? parameter(element) : parameter;
949
		});
950
		
951
		// clean number parameters
952
		$.each(['minlength', 'maxlength', 'min', 'max'], function() {
953
			if (rules[this]) {
954
				rules[this] = Number(rules[this]);
955
			}
956
		});
957
		$.each(['rangelength', 'range'], function() {
958
			if (rules[this]) {
959
				rules[this] = [Number(rules[this][0]), Number(rules[this][1])];
960
			}
961
		});
962
		
963
		if ($.validator.autoCreateRanges) {
964
			// auto-create ranges
965
			if (rules.min && rules.max) {
966
				rules.range = [rules.min, rules.max];
967
				delete rules.min;
968
				delete rules.max;
969
			}
970
			if (rules.minlength && rules.maxlength) {
971
				rules.rangelength = [rules.minlength, rules.maxlength];
972
				delete rules.minlength;
973
				delete rules.maxlength;
974
			}
975
		}
976
		
977
		// To support custom messages in metadata ignore rule methods titled "messages"
978
		if (rules.messages) {
979
			delete rules.messages;
980
		}
981
		
982
		return rules;
983
	},
984
	
985
	// Converts a simple string to a {string: true} rule, e.g., "required" to {required:true}
986
	normalizeRule: function(data) {
987
		if( typeof data == "string" ) {
988
			var transformed = {};
989
			$.each(data.split(/\s/), function() {
990
				transformed[this] = true;
991
			});
992
			data = transformed;
993
		}
994
		return data;
995
	},
996
	
997
	// http://docs.jquery.com/Plugins/Validation/Validator/addMethod
998
	addMethod: function(name, method, message) {
999
		/// <summary>
1000
		/// Add a custom validation method. It must consist of a name (must be a legal javascript 
1001
		/// identifier), a javascript based function and a default string message.
1002
		/// </summary>
1003
		/// <param name="name" type="String">
1004
		/// The name of the method, used to identify and referencing it, must be a valid javascript
1005
		/// identifier
1006
		/// </param>
1007
		/// <param name="method" type="Function">
1008
		/// The actual method implementation, returning true if an element is valid
1009
		/// </param>
1010
		/// <param name="message" type="String" optional="true">
1011
		/// (Optional) The default message to display for this method. Can be a function created by 
1012
		/// jQuery.validator.format(value). When undefined, an already existing message is used 
1013
		/// (handy for localization), otherwise the field-specific messages have to be defined.
1014
		/// </param>
1015

1016
		$.validator.methods[name] = method;
1017
		$.validator.messages[name] = message != undefined ? message : $.validator.messages[name];
1018
		if (method.length < 3) {
1019
			$.validator.addClassRules(name, $.validator.normalizeRule(name));
1020
		}
1021
	},
1022

1023
	methods: {
1024

1025
		// http://docs.jquery.com/Plugins/Validation/Methods/required
1026
		required: function(value, element, param) {
1027
			// check if dependency is met
1028
			if ( !this.depend(param, element) )
1029
				return "dependency-mismatch";
1030
			switch( element.nodeName.toLowerCase() ) {
1031
			case 'select':
1032
				// could be an array for select-multiple or a string, both are fine this way
1033
				var val = $(element).val();
1034
				return val && val.length > 0;
1035
			case 'input':
1036
				if ( this.checkable(element) )
1037
					return this.getLength(value, element) > 0;
1038
			default:
1039
				return $.trim(value).length > 0;
1040
			}
1041
		},
1042
		
1043
		// http://docs.jquery.com/Plugins/Validation/Methods/remote
1044
		remote: function(value, element, param) {
1045
			if ( this.optional(element) )
1046
				return "dependency-mismatch";
1047
			
1048
			var previous = this.previousValue(element);
1049
			if (!this.settings.messages[element.name] )
1050
				this.settings.messages[element.name] = {};
1051
			previous.originalMessage = this.settings.messages[element.name].remote;
1052
			this.settings.messages[element.name].remote = previous.message;
1053
			
1054
			param = typeof param == "string" && {url:param} || param; 
1055
			
1056
			if ( this.pending[element.name] ) {
1057
				return "pending";
1058
			}
1059
			if ( previous.old === value ) {
1060
				return previous.valid;
1061
			}
1062

1063
			previous.old = value;
1064
			var validator = this;
1065
			this.startRequest(element);
1066
			var data = {};
1067
			data[element.name] = value;
1068
			$.ajax($.extend(true, {
1069
				url: param,
1070
				mode: "abort",
1071
				port: "validate" + element.name,
1072
				dataType: "json",
1073
				data: data,
1074
				success: function(response) {
1075
					validator.settings.messages[element.name].remote = previous.originalMessage;
1076
					var valid = response === true;
1077
					if ( valid ) {
1078
						var submitted = validator.formSubmitted;
1079
						validator.prepareElement(element);
1080
						validator.formSubmitted = submitted;
1081
						validator.successList.push(element);
1082
						validator.showErrors();
1083
					} else {
1084
						var errors = {};
1085
						var message = response || validator.defaultMessage(element, "remote");
1086
						errors[element.name] = previous.message = $.isFunction(message) ? message(value) : message;
1087
						validator.showErrors(errors);
1088
					}
1089
					previous.valid = valid;
1090
					validator.stopRequest(element, valid);
1091
				}
1092
			}, param));
1093
			return "pending";
1094
		},
1095

1096
		// http://docs.jquery.com/Plugins/Validation/Methods/minlength
1097
		minlength: function(value, element, param) {
1098
			return this.optional(element) || this.getLength($.trim(value), element) >= param;
1099
		},
1100
		
1101
		// http://docs.jquery.com/Plugins/Validation/Methods/maxlength
1102
		maxlength: function(value, element, param) {
1103
			return this.optional(element) || this.getLength($.trim(value), element) <= param;
1104
		},
1105
		
1106
		// http://docs.jquery.com/Plugins/Validation/Methods/rangelength
1107
		rangelength: function(value, element, param) {
1108
			var length = this.getLength($.trim(value), element);
1109
			return this.optional(element) || ( length >= param[0] && length <= param[1] );
1110
		},
1111
		
1112
		// http://docs.jquery.com/Plugins/Validation/Methods/min
1113
		min: function( value, element, param ) {
1114
			return this.optional(element) || value >= param;
1115
		},
1116
		
1117
		// http://docs.jquery.com/Plugins/Validation/Methods/max
1118
		max: function( value, element, param ) {
1119
			return this.optional(element) || value <= param;
1120
		},
1121
		
1122
		// http://docs.jquery.com/Plugins/Validation/Methods/range
1123
		range: function( value, element, param ) {
1124
			return this.optional(element) || ( value >= param[0] && value <= param[1] );
1125
		},
1126
		
1127
		// http://docs.jquery.com/Plugins/Validation/Methods/email
1128
		email: function(value, element) {
1129
			// contributed by Scott Gonzalez: http://projects.scottsplayground.com/email_address_validation/
1130
			return this.optional(element) || /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?$/i.test(value);
1131
		},
1132
	
1133
		// http://docs.jquery.com/Plugins/Validation/Methods/url
1134
		url: function(value, element) {
1135
			// contributed by Scott Gonzalez: http://projects.scottsplayground.com/iri/
1136
			return this.optional(element) || /^(https?|ftp):\/\/(((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)+(\/(([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(\#((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|\/|\?)*)?$/i.test(value);
1137
		},
1138
        
1139
		// http://docs.jquery.com/Plugins/Validation/Methods/date
1140
		date: function(value, element) {
1141
			return this.optional(element) || !/Invalid|NaN/.test(new Date(value));
1142
		},
1143
	
1144
		// http://docs.jquery.com/Plugins/Validation/Methods/dateISO
1145
		dateISO: function(value, element) {
1146
			return this.optional(element) || /^\d{4}[\/-]\d{1,2}[\/-]\d{1,2}$/.test(value);
1147
		},
1148
	
1149
		// http://docs.jquery.com/Plugins/Validation/Methods/number
1150
		number: function(value, element) {
1151
			return this.optional(element) || /^-?(?:\d+|\d{1,3}(?:,\d{3})+)(?:\.\d+)?$/.test(value);
1152
		},
1153
	
1154
		// http://docs.jquery.com/Plugins/Validation/Methods/digits
1155
		digits: function(value, element) {
1156
			return this.optional(element) || /^\d+$/.test(value);
1157
		},
1158
		
1159
		// http://docs.jquery.com/Plugins/Validation/Methods/creditcard
1160
		// based on http://en.wikipedia.org/wiki/Luhn
1161
		creditcard: function(value, element) {
1162
			if ( this.optional(element) )
1163
				return "dependency-mismatch";
1164
			// accept only digits and dashes
1165
			if (/[^0-9-]+/.test(value))
1166
				return false;
1167
			var nCheck = 0,
1168
				nDigit = 0,
1169
				bEven = false;
1170

1171
			value = value.replace(/\D/g, "");
1172

1173
			for (var n = value.length - 1; n >= 0; n--) {
1174
				var cDigit = value.charAt(n);
1175
				var nDigit = parseInt(cDigit, 10);
1176
				if (bEven) {
1177
					if ((nDigit *= 2) > 9)
1178
						nDigit -= 9;
1179
				}
1180
				nCheck += nDigit;
1181
				bEven = !bEven;
1182
			}
1183

1184
			return (nCheck % 10) == 0;
1185
		},
1186
		
1187
		// http://docs.jquery.com/Plugins/Validation/Methods/accept
1188
		accept: function(value, element, param) {
1189
			param = typeof param == "string" ? param.replace(/,/g, '|') : "png|jpe?g|gif";
1190
			return this.optional(element) || value.match(new RegExp(".(" + param + ")$", "i")); 
1191
		},
1192
		
1193
		// http://docs.jquery.com/Plugins/Validation/Methods/equalTo
1194
		equalTo: function(value, element, param) {
1195
			// bind to the blur event of the target in order to revalidate whenever the target field is updated
1196
			// TODO find a way to bind the event just once, avoiding the unbind-rebind overhead
1197
			var target = $(param).unbind(".validate-equalTo").bind("blur.validate-equalTo", function() {
1198
				$(element).valid();
1199
			});
1200
			return value == target.val();
1201
		}
1202
		
1203
	}
1204
	
1205
});
1206

1207
// deprecated, use $.validator.format instead
1208
$.format = $.validator.format;
1209

1210
})(jQuery);
1211

1212
// ajax mode: abort
1213
// usage: $.ajax({ mode: "abort"[, port: "uniqueport"]});
1214
// if mode:"abort" is used, the previous request on that port (port can be undefined) is aborted via XMLHttpRequest.abort() 
1215
;(function($) {
1216
	var pendingRequests = {};
1217
		// Use a prefilter if available (1.5+)
1218
	if ( $.ajaxPrefilter ) {
1219
		$.ajaxPrefilter(function(settings, _, xhr) {
1220
		    var port = settings.port;
1221
		    if (settings.mode == "abort") {
1222
			    if ( pendingRequests[port] ) {
1223
				    pendingRequests[port].abort();
1224
			    }				pendingRequests[port] = xhr;
1225
		    }
1226
	    });
1227
	} else {
1228
		// Proxy ajax
1229
		var ajax = $.ajax;
1230
		$.ajax = function(settings) {
1231
			var mode = ( "mode" in settings ? settings : $.ajaxSettings ).mode,
1232
				port = ( "port" in settings ? settings : $.ajaxSettings ).port;
1233
			if (mode == "abort") {
1234
				if ( pendingRequests[port] ) {
1235
					pendingRequests[port].abort();
1236
				}
1237

1238
			    return (pendingRequests[port] = ajax.apply(this, arguments));
1239
		    }
1240
		    return ajax.apply(this, arguments);
1241
	    };
1242
    }
1243
})(jQuery);
1244

1245
// provides cross-browser focusin and focusout events
1246
// IE has native support, in other browsers, use event caputuring (neither bubbles)
1247

1248
// provides delegate(type: String, delegate: Selector, handler: Callback) plugin for easier event delegation
1249
// handler is only called when $(event.target).is(delegate), in the scope of the jquery-object for event.target 
1250
;(function($) {
1251
	// only implement if not provided by jQuery core (since 1.4)
1252
	// TODO verify if jQuery 1.4's implementation is compatible with older jQuery special-event APIs
1253
	if (!jQuery.event.special.focusin && !jQuery.event.special.focusout && document.addEventListener) {
1254
		$.each({
1255
			focus: 'focusin',
1256
			blur: 'focusout'	
1257
		}, function( original, fix ){
1258
			$.event.special[fix] = {
1259
				setup:function() {
1260
					this.addEventListener( original, handler, true );
1261
				},
1262
				teardown:function() {
1263
					this.removeEventListener( original, handler, true );
1264
				},
1265
				handler: function(e) {
1266
					arguments[0] = $.event.fix(e);
1267
					arguments[0].type = fix;
1268
					return $.event.handle.apply(this, arguments);
1269
				}
1270
			};
1271
			function handler(e) {
1272
				e = $.event.fix(e);
1273
				e.type = fix;
1274
				return $.event.handle.call(this, e);
1275
			}
1276
		});
1277
	};
1278
	$.extend($.fn, {
1279
		validateDelegate: function(delegate, type, handler) {
1280
			return this.bind(type, function(event) {
1281
				var target = $(event.target);
1282
				if (target.is(delegate)) {
1283
					return handler.apply(target, arguments);
1284
				}
1285
			});
1286
		}
1287
	});
1288
})(jQuery);
1289