说明： Online Clinic Management System Project is based on the hospital Management System The first and only clinic management software / system that full fills all needs in the clinic management field, all things like managing the reception printing the prescription, patient record, bill printing and many more at one place with fully expertise and error free operations.
jQuery.validationEngine v2.2.3
=====
Summary
---
**jQuery validation** engine is a Javascript plugin aimed at the validation of form fields in the browser (IE 6-8, Chrome, Firefox, Safari, Opera 10).
The plugin provides visually appealing prompts that grab user attention on the subject matter.
Validations range from email, phone, and URL, to more complex calls such as ajax processing or custom javascript functions.
Bundled with many locales, the error prompts can be translated into the language of your choice.
Forum Support: http://validationengine.vanillaforums.com/
**Important**: v2 is a significant rewrite of the original 1.7 branch. Please read the documentation as the API has changed!
Demo :
---
[http://www.position-relative.net/creation/formValidator/](http://www.position-relative.net/creation/formValidator/)
Installation
---
### What's in the archive?
The archive holds, of course, the core library along with translations in different languages.
It also comes with a set of demo pages and a simple ajax server (built in Java).
1. Unpack the archive
2. Include the script jquery.validationEngine.closure.js in your page
3. Pick the locale of the choice and include it in your page: jquery.validationEngine-XX.js
4. **Read this manual** and understand the API
### Running the Demos
Most demos are fully functional by simply opening their respective HTML file. However, the Ajax demos require the use of Java6 to launch a lightweight http server.
1. Run the script `runDemo.bat` (Windows) or `runDemo.sh` (Unix) from the folder
2. Open a browser and point it at [http://localhost:9173](http://localhost:9173)
Usage
---
### References
First include jQuery on your page
```html
```
Include *jquery.validationEngine* and its locale
```html
```
Finally include the desired theme
```html
```
### Field Validations
Validations are defined using the field's **class** attribute. Here are a few examples showing how it happens:
```html
```
For more details about validators, please refer to the section below.
### Per Field Prompt Direction
Prompt direction can be define using the field's **data** attribute. Here are a few examples showing how it happens:
```html
```
### Prompt Position Adjustment
Prompt position can be adjusted by providing shiftX and shiftY with position type in the field's **data** attribute.
Prompt will be placed in (defaultX+shiftX),(defaultY+shiftY) position instead of default for selected position type.
Here are a few examples showing how it happens:
```html
```
### Instantiation
The validator is typically instantiated with a call in the following format, the plugin can only be instanciated on form elements:
```js
$("#form.id").validationEngine();
```
Without any parameters, the init() and attach() methods are automatically called.
```js
$("#form.id").validationEngine(action or options);
```
The method may take one or several parameters, either an action (and parameters) or a list of options to customize the behavior of the engine.
Here's a glimpse: say you have a form as such:
```html
```
The code below will instantiate the validation engine and attach it to the form:
```html
```
When using options, the default behavior is to only initialize ValidationEngine, so attachment needs to be done manually.
```html
```
All calls to validationEngine() are chainable, so one can do the following:
```js
$("#formID").validationEngine().css({border : "2px solid #000"});
```
Actions
---
### attach
Attaches jQuery.validationEngine to form.submit and field.blur events.
```js
$("#formID1").validationEngine('attach');
```
### detach
Unregisters any bindings that may point to jQuery.validaitonEngine.
```js
$("#formID1").validationEngine('detach');
```
### validate
Validates the form and displays prompts accordingly.
Returns *true* if the form validates, *false* if it contains errors. Note that if you use an ajax form validator, the actual result will be delivered asynchronously to the function *options.onAjaxFormComplete*.
```js
alert( $("#formID1").validationEngine('validate') );
```
### validate one field
Validates one field and displays the prompt accordingly.
Returns *false* if the input validates, *true* if it contains errors.
```js
alert( $("#formID1").validationEngine('validateField', "#emailInput") );
```
### showPrompt (promptText, type, promptPosition, showArrow)
Displays a prompt on a given element. Note that the prompt can be displayed on any element by providing an id.
The method takes four parameters:
1. the text of the prompt itself
2. a type which defines the visual look of the prompt: 'pass' (green), 'load' (black) anything else (red)
3. an optional position: either "topLeft", "topRight", "bottomLeft", "centerRight", "bottomRight". Defaults to *"topRight"*
4. an optional boolean which indicates if the prompt should display a directional arrow
```html
```
### hidePrompt
Closes the prompt linked to the input.
```js
$('#inputID').validationEngine('hidePrompt');
```
### hide
Closes error prompts in the current form (in case you have more than one form on the page).
```js
$('#formID1').validationEngine('hide');
```
### hideAll
Closes **all** error prompts on the page.
```js
$('#formID1').validationEngine('hideAll');
```
### updatePromptsPosition
Update the form prompts positions.
```js
$("#formID").validationEngine("updatePromptsPosition")
```
Options
---
Options are typically passed to the init or attach action as a parameter.
```js
$("#formID1").validationEngine({promptPosition : "centerRight", scroll: false});
$("#formID1").validationEngine('attach', {promptPosition : "centerRight", scroll: false});
```
### validationEventTrigger
Name of the event triggering field validation, defaults to *blur*.
### scroll
Determines if we should scroll the page to the first error, defaults to *true*.
### promptPosition
Where should the prompt show? Possible values are "topLeft", "topRight", "bottomLeft", "centerRight", "bottomRight". Defaults to *"topRight"*.
Default position adjustment could also be provided.
### ajaxFormValidation
If set to true, turns Ajax form validation logic on. Defaults to *false*.
Form validation takes place when the validate() action is called or when the form is submitted.
### ajaxFormValidationURL
If set, the ajax submit validation will use this url instead of the form action
### onBeforeAjaxFormValidation(form, options)
When ajaxFormValidation is turned on, this is the function that will be called before the asynchronous AJAX form validation call. May return false to stop the Ajax form validation
### onAjaxFormComplete: function(status, form, errors, options)
When ajaxFormValidation is turned on, this function is used to asynchronously process the result of the validation. the status is a boolean. If true, the ajax call completed and all the server side form validations passed.
### relative
Set to true when the form shows in a scrolling div, defaults to *false*, the error boxes are appended after the input instead of body
### onValidationComplete
When defined, stops the the form from auto-submitting, and lets you handle the validation status via a function
```js
jQuery("#formID2").validationEngine('attach', {
onValidationComplete: function(form, status){
alert("The form status is: " +status+", it will never submit");
}
});
```
### onSuccess
If set, this callback function will be called when all validations passed.
### onFailure
If set, this callback function will be called when it found an error.
### autoPositionUpdate
Auto update prompt position after window resize, disabled by default
### autoHidePrompt
Determines if the prompt should hide itself automatically after a set period. Defaults to *false*.
### autoHideDelay
Sets the number of ms that the prompt should appear for if autoHidePrompt is set to *true*. Defaults to *2000*.
Validators
---
Validators are encoded in the field's class attribute, as follows
### required
Speaks for itself, fails if the element has no value. This validator can apply to pretty much any kind of input field.
```html
```
### groupRequired
At least one of the field of the group must be filled. It needs to be given a group name that is unique across the form.
```html
```
### custom[regex_name]
Validates the element's value to a predefined list of regular expressions.
```html
```
Please refer to the section *Custom Regex* for a list of available regular expressions.
### funcCall[methodName]
Validates a field using a third party function call. If a validation error occurs, the function must return an error message that will automatically show in the error prompt.
```js
function checkHELLO(field, rules, i, options){
if (field.val() != "HELLO") {
// this allows the use of i18 for the error msgs
return options.allrules.validate2fields.alertText;
}
}
```
The following declaration will do
```html
```
### ajax[selector]
Delegates the validation to a server URL using an asynchronous Ajax request. The selector is used to identify a block of properties in the translation file, take the following for example.
```html
```
```js
"ajaxUserCall": {
"url": "ajaxValidateFieldUser",
"extraData": "name=eric",
"extraDataDynamic": ['#user_id', '#user_email'],
"alertText": "* This user is already taken",
"alertTextOk": "All good!",
"alertTextLoad": "* Validating, please wait"
},
```
* url - is the remote restful service to call
* extraData - optional parameters to send
* extraDataDynamic - optional DOM id's that should have their values sent as parameters
* alertText - error prompt message if validation fails
* alertTextOk - optional prompt if validation succeeds (shows green)
* alertTextLoad - message displayed while the validation is being performed
This validator is explained in further details in the Ajax section.
### equals[field.id]
Checks if the current field's value equals the value of the specified field.
### min[float]
Validates when the field's value is less than, or equal to, the given parameter.
### max[float]
Validates when the field's value is more than, or equal to, the given parameter.
### minSize[integer]
Validates if the element content size (in characters) is more than, or equal to, the given *integer*. integer <= input.value.length
### maxSize[integer]
Validates if the element content size (in characters) is less than, or equal to, the given *integer*. input.value.length <= integer
### past[NOW or a date]
Checks if the element's value (which is implicitly a date) is earlier than the given *date*. When "NOW" is used as a parameter, the date will be calculate in the browser. Note that this may be different from the server date. Dates use the ISO format YYYY-MM-DD
```html
```
### future[NOW or a date]
Checks if the element's value (which is implicitly a date) is greater than the given *date*. When "NOW" is used as a parameter, the date will be calculate in the browser. Note that this may be different from the server date. Dates use the ISO format YYYY-MM-DD
```html
// a date in 2009
```
### minCheckbox[integer]
Validates when a minimum of *integer* checkboxes are selected.
The validator uses a special naming convention to identify the checkboxes as part of a group.
The following example, enforces a minimum of two selected checkboxes
```html
```
Note how the input.name is identical across the fields.
### maxCheckbox[integer]
Same as above but limits the maximum number of selected check boxes.
Selectors
---
We've introduced the notion of selectors without giving many details about them: A selector is a string which is used as a key to match properties in the translation files.
Take the following example:
```js
"onlyNumber": {
"regex": /^[0-9\ ]+$/,
"alertText": "* Numbers only"
},
"ajaxUserCall": {
"url": "ajaxValidateFieldUser",
"extraData": "name=eric",
"alertText": "* This user is already taken",
"alertTextOk": " * User is valid",
"alertTextLoad": "* Validating, please wait"
},
"validate2fields": {
"alertText": "* Please input HELLO"
}
```
onlyNumber, onlyLetter and validate2fields are all selectors. jQuery.validationEngine comes with a standard set but you are welcome to add you own to define AJAX backend services, error messages and/or new regular expressions.
The ValidationEngine with a datepicker
---
Using a datepicker with the engine is problematic because the validation is bound to the blur event. since we lose the focus before any data is entered in the field it creates a weird bug.
Fortunately we implemented a fix that uses a delay during the datepicker binding.
To use this mode you need to add the class *datepicker* to your input, like this:
```html
```
Ajax Protocol
---
The ajax validator takes a selector as an attribute. the selector points to a structure that defines the URL to call, the different messages to display and any extra parameters to add on the URL (when applicable). Please refer to the **ajax[selector]** description for more details.
Ajax validation comes in two flavors:
1. Field Ajax validations, which take place when the user inputs a value in a field and moves away.
2. Form Ajax validation, which takes place when the form is submitted or when the validate() action is called.
Both options are optional.
```html
```
You can see a tutorial that makes the use of php here: [http://www.position-absolute.com/articles/using-form-ajax-validation-with-the-jquery-validation-engine-plugin/](http://www.position-absolute.com/articles/using-form-ajax-validation-with-the-jquery-validation-engine-plugin/)
### Field ajax validation
####Protocol
The client sends the fieldId and the fieldValue as a GET request to the server url.
Client calls url?fieldId=id1&fieldValue=value1 ==> Server
Server responds with an array: [fieldid, status, errorMsg].
Client receives <== ["id1", boolean, errorMsg] Server
* fieldid is the name (id) of the field
* status is the result of the validation, true if it passes, false if it fails
* errorMsg is an optional error string (or a selector) to the prompt text. If no error msg is returned, the prompt message is expected to be part of the rule with key "alertText" or "alertTextOk" (see the structure of the translation file)
### Form ajax validation
####Protocol
The client sends the form fields and values as a GET request to the form.action url.
Client calls url?fieldId=id1&fieldValue=value1&...etc ==> Server (form.action)
Server responds with an *array of arrays*: [fieldid, status, errorMsg].
* fieldid is the name (id) of the field
* status is the result of the validation, true if it passes, false if it fails
* errorMsg is an error string (or a selector) to the prompt text
Client receives <== [["id1", boolean,"errorMsg"],["id2", false, "there is an error "],["id3", true, "this field is good"]]
Note that normally errors (status=false) are returned from the server. However you may also decide to return an entry with a status=true in which case the errorMsg will show as a green prompt.
####Validation URL
By de ... ...