Pagina 1 di 2 1 2 ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 20
  1. #1

    Codice CAPTCHA in Javascript

    Ragazzi salve a tutti, sto cercando di implementare un form di registrazione ad un sito che abbia anche il controllo di sicurezza captcha.
    Tutto funziona alla grande, solo che si ignora il controllo proprio su quest'ultimo.
    Vi posto il codice.. Se avere suggerimenti da darmi ve ne sarei molto grata. Grazie

    <!DOCTYPE html>

    <html>
    <head>

    <title>Registration</title>
    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
    <script language="JavaScript" type="text/javascript" src="js/jquery-1.3.2.min.js"></script>
    <script language="JavaScript" type="text/javascript" src="js/jquery.validate.js"></script>

    <script language="javascript">
    function Modulo() {
    // Variabili associate ai campi del modulo
    var nome = document.modulo.full_name.value;
    var indirizzo = document.modulo.address.value;
    var nazione = document.modulo.country.value;
    var telefono = document.modulo.tel.value;
    var fax = document.modulo.fax.value;
    var website = document.modulo.web.value;

    var user = document.modulo.user_name.value;
    var email = document.modulo.usr_email.value;
    var pass = document.modulo.pwd.value;
    var pass2 = document.modulo.pwd2.value;

    var codice = document.modulo.codice.value;

    // Resettiamo il colore di sfondo dei moduli

    document.modulo.full_name.style.backgroundColor="" ;
    document.modulo.address.style.backgroundColor="";
    document.modulo.country.style.backgroundColor="";
    document.modulo.tel.style.backgroundColor="";
    document.modulo.fax.style.backgroundColor="";
    document.modulo.web.style.backgroundColor="";
    document.modulo.user_name.style.backgroundColor="" ;
    document.modulo.usr_email.style.backgroundColor="" ;
    document.modulo.pwd.style.backgroundColor="";
    document.modulo.pwd2.style.backgroundColor="";


    // Espressione regolare dell'email
    var email_reg_exp = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-]{2,})+\.)+([a-zA-Z0-9]{2,})+$/;

    //Effettua il controllo sul campo FULL_NAME
    if ((nome == "") || (nome == "undefined")) {
    alert("Il campo Nome è obbligatorio.");
    document.modulo.full_name.focus();
    document.modulo.full_name.style.backgroundColor="r ed";
    return false;
    }

    //Effettua il controllo sul campo ADDRESS
    else if ((indirizzo == "") || (indirizzo == "undefined")) {
    alert("Il campo Indirizzo è obbligatorio.");
    document.modulo.address.focus();
    document.modulo.address.style.backgroundColor="red ";
    return false;
    }

    //Effettua il controllo sul campo COUNTRY
    else if ((nazione == "") || (nazione == "undefined")) {
    alert("Il campo Nazione è obbligatorio.");
    document.modulo.tel.focus();
    document.modulo.tel.style.backgroundColor="red";
    return false;
    }

    //Effettua il controllo sul campo TEL
    else if ((telefono == "") || (telefono == "undefined")) {
    alert("Il campo Telefono è obbligatorio.");
    document.modulo.country.focus();
    document.modulo.country.style.backgroundColor="red ";
    return false;
    }

    else if (!email_reg_exp.test(email) || (email == "") || (email == "undefined")) {
    alert("Inserire un indirizzo email corretto.");
    document.modulo.usr_email.select();
    document.modulo.email.style.backgroundColor="red";
    return false;
    }
    else if ((codice != document.getElementById("captcha").innerText) || (codice=="") || (codice=="undefined")){

    alert("Il codice di sicurezza è errato!");
    document.modulo.codice.select();
    document.modulo.codice.style.backgroundColor="red" ;
    return false;
    }

    //INVIA IL MODULO
    else {
    document.modulo.action = "avvenuto.php ";
    document.modulo.submit();
    }
    }
    $(document).ready(function(){
    $.validator.addMethod("username", function(value, element) {
    return this.optional(element) || /^[a-z0-9\_]+$/i.test(value);
    }, "Username must contain only letters, numbers, or underscore.");

    $("#regForm").validate();
    });


    function CAPTCHA()
    {
    var car, min, max, dif, lun, inc;
    car = "abcdefghijklmnopqrstuvwxyz";
    car += "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    car += "1234567890";
    min = 5;
    max = 5;
    dif = max - min;
    lun = Math.round((Math.random() * dif) + min);
    inc = 0;
    cod = "";
    while (inc < lun)
    {
    cod += car.charAt(Math.round(Math.random() * car.length));
    inc++;
    }
    return cod;
    }

    </script>

    <link href="styles.css" rel="stylesheet" type="text/css">
    </head>

    <body>
    <header>
    <h1>Semantic Multimedia Retrieval</h1>
    </header>
    <div id="container">
    <aside>
    <table width="100%" border="0" cellspacing="0" cellpadding="5" class="main2">
    <tr>
    <td colspan="3"></td>
    </tr>
    <tr>
    <td width="160" valign="top">

    </p>


    </p>


    </p>


    </p>


    </p></td>
    <td width="732" valign="top">






    <form action="avvenuto.php" method="post" name="regForm" id="regForm" >
    <table width="95%" border="0" cellpadding="3" cellspacing="3" class="forms">
    <tr>
    <td colspan="2">Your Name / Company Name<span class="required"><font color="#CC0000">*</font></span>

    <input name="full_name" type="text" id="full_name" size="40" class="required"></td>
    </tr>
    <tr>
    <td colspan="2"></td>
    </tr>
    <tr>
    <td colspan="2">Contact Address (with ZIP)<span class="required"><font color="#CC0000">*</font></span>

    <textarea name="address" cols="40" rows="4" id="address" class="required"></textarea>
    <span class="example">VALID CONTACT DETAILS</span> </td>
    </tr>
    <tr>
    <td>Country <font color="#CC0000">*</font></span></td>
    <td><select name="country" class="required" id="select8">
    <option value="" selected></option>
    <option value="Afghanistan">Afghanistan</option>

    <option value="Yugoslavia">Yugoslavia</option>
    </select></td>
    </tr>
    <tr>
    <td>Phone<span class="required"><font color="#CC0000">*</font></span>
    </td>
    <td><input name="tel" type="text" id="tel" class="required"></td>
    </tr>
    <tr>
    <td>Fax </td>
    <td><input name="fax" type="text" id="fax">
    </td>
    </tr>
    <tr>
    <td>Website </td>
    <td><input name="web" type="text" id="web" class="optional defaultInvalid url">
    <span class="example">http://www.example.com</span></td>
    </tr>
    <tr>
    <td colspan="2"></td>
    </tr>
    <tr>
    <td colspan="2"><h4>Login Details</h4></td>
    </tr>
    <tr>
    <td>Username<span class="required"><font color="#CC0000">*</font></span></td>
    <td><input name="user_name" type="text" id="user_name" class="required username" minlength="5" >
    <input name="btnAvailable" type="button" id="btnAvailable"
    onclick='$("#checkid").html("Please wait..."); $.get("checkuser.php",{ cmd: "check", user: $("#user_name").val() } ,function(data){ $("#checkid").html(data); });'
    value="Check Availability">
    <span style="color:red; font: bold 12px verdana; " id="checkid" ></span>
    </td>
    </tr>
    <tr>
    <td>Your Email<span class="required"><font color="#CC0000">*</font></span>
    </td>
    <td><input name="usr_email" type="text" id="usr_email3" class="required email">
    <span class="example">** Valid email please..</span></td>
    </tr>
    <tr>
    <td>Password<span class="required"><font color="#CC0000">*</font></span>
    </td>
    <td><input name="pwd" type="password" class="required password" minlength="5" id="pwd">
    <span class="example">** 5 chars minimum..</span></td>
    </tr>
    <tr>
    <td>Retype Password<span class="required"><font color="#CC0000">*</font></span>
    </td>
    <td><input name="pwd2" id="pwd2" class="required password" type="password" minlength="5" equalto="#pwd"></td>
    </tr>
    <tr>
    <td colspan="2"></td>
    </tr>
    <tr>
    <td>

    Copia il codice di sicurezza:
    <span id="captcha">
    <script type="text/javascript" language="JavaScript">
    document.getElementById("captcha").innerText = CAPTCHA();
    </script>
    </span>


    <input type="text" name="codice" size="50">



    </td>
    </tr>
    </table>
    <p align="center">
    <input name="doRegister" type="submit" id="doRegister" value="Register">
    </p>
    </form>


    </td>
    <td width="196" valign="top"></td>
    </tr>
    <tr>
    <td colspan="3"></td>
    </tr>
    </table>
    </aside>
    </div>
    </body>
    </html>

  2. #2
    Moderatore di JavaScript L'avatar di br1
    Registrato dal
    Jul 1999
    Messaggi
    19,998
    Dov'e' il form con name="modulo" ?
    Il guaio per i poveri computers e' che sono gli uomini a comandarli.

    Attenzione ai titoli delle discussioni: (ri)leggete il regolamento
    Consultate la discussione in rilievo: script / discussioni utili
    Usate la funzione di Ricerca del Forum

  3. #3
    Utente di HTML.it
    Registrato dal
    Dec 2010
    Messaggi
    3,660
    la funzione Modulo non viene proprio utilizzata, non so a che serve e perche l'hai postata visto che stai utilizzando il plugin validate di jquery ti basta aggiungere un metodo per il controllo del captcha:

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

    e aggiungere il class captcha nel campo "codice", come hai fatto con gli altri campi del form

  4. #4
    scusate ragazzi, siccome non è una cosa che ho fatto io di sana pianta (come penso si sia capito) come posso materialmente modificare questo file (jquery.validate.js) ??? Non da dove iniziare

  5. #5
    Utente di HTML.it
    Registrato dal
    Dec 2010
    Messaggi
    3,660
    non ho mica detto che devi modificare quel file

    Chi ha scritto quel codice, sta utilizzando un plugin di jquery per la validazione dei campi del form(jquery validate), questa è la parte che ti interessa:

    codice:
    $(document).ready(function(){
     $.validator.addMethod("username", function(value, element) {
     return this.optional(element) || /^[a-z0-9\_]+$/i.test(value);
     }, "Username must contain only letters, numbers, or underscore.");
     
    $("#regForm").validate();
     });
    Devi aggiungere un ulteriore metodo che controlli il captcha

  6. #6
    Ma se volessi usare solo la funzione modulo javascript da me realizzata come posso modificarla?? secondo voi ci sarebbero cmq problemi di funzionamento? ... Il problema è che non so modificare il file validate di jquery

  7. #7
    Scusa Vindav... ma non ho capito cosa mi vuoi dire.. io ho questo codice jquery.validate.js
    (function($) {

    $.extend($.fn, {
    // http://docs.jquery.com/Plugins/Validation/validate
    validate: function( options ) {

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

    // check if a validator for this form was already created
    var validator = $.data(this[0], 'validator');
    if ( validator ) {
    return validator;
    }

    validator = new $.validator( options, this[0] );
    $.data(this[0], 'validator', validator);

    if ( validator.settings.onsubmit ) {

    // allow suppresing validation by adding a cancel class to the submit button
    this.find("input, button").filter(".cancel").click(function() {
    validator.cancelSubmit = true;
    });

    // when a submitHandler is used, capture the submitting button
    if (validator.settings.submitHandler) {
    this.find("input, button").filter(":submit").click(function() {
    validator.submitButton = this;
    });
    }

    // validate the form on submit
    this.submit( function( event ) {
    if ( validator.settings.debug )
    // prevent form submit to be able to see console output
    event.preventDefault();

    function handle() {
    if ( validator.settings.submitHandler ) {
    if (validator.submitButton) {
    // insert a hidden input as a replacement for the missing submit button
    var hidden = $("<input type='hidden'/>").attr("name", validator.submitButton.name).val(validator.submitB utton.value).appendTo(validator.currentForm);
    }
    validator.settings.submitHandler.call( validator, validator.currentForm );
    if (validator.submitButton) {
    // and clean up afterwards; thanks to no-block-scope, hidden can be referenced
    hidden.remove();
    }
    return false;
    }
    return true;
    }

    // prevent submit for invalid forms or custom submit handlers
    if ( validator.cancelSubmit ) {
    validator.cancelSubmit = false;
    return handle();
    }
    if ( validator.form() ) {
    if ( validator.pendingRequest ) {
    validator.formSubmitted = true;
    return false;
    }
    return handle();
    } else {
    validator.focusInvalid();
    return false;
    }
    });
    }

    return validator;
    },
    // http://docs.jquery.com/Plugins/Validation/valid
    valid: function() {
    if ( $(this[0]).is('form')) {
    return this.validate().form();
    } else {
    var valid = true;
    var validator = $(this[0].form).validate();
    this.each(function() {
    valid &= validator.element(this);
    });
    return valid;
    }
    },
    // attributes: space seperated list of attributes to retrieve and remove
    removeAttrs: function(attributes) {
    var result = {},
    $element = this;
    $.each(attributes.split(/\s/), function(index, value) {
    result[value] = $element.attr(value);
    $element.removeAttr(value);
    });
    return result;
    },
    // http://docs.jquery.com/Plugins/Validation/rules
    rules: function(command, argument) {
    var element = this[0];

    if (command) {
    var settings = $.data(element.form, 'validator').settings;
    var staticRules = settings.rules;
    var existingRules = $.validator.staticRules(element);
    switch(command) {
    case "add":
    $.extend(existingRules, $.validator.normalizeRule(argument));
    staticRules[element.name] = existingRules;
    if (argument.messages)
    settings.messages[element.name] = $.extend( settings.messages[element.name], argument.messages );
    break;
    case "remove":
    if (!argument) {
    delete staticRules[element.name];
    return existingRules;
    }
    var filtered = {};
    $.each(argument.split(/\s/), function(index, method) {
    filtered[method] = existingRules[method];
    delete existingRules[method];
    });
    return filtered;
    }
    }

    var data = $.validator.normalizeRules(
    $.extend(
    {},
    $.validator.metadataRules(element),
    $.validator.classRules(element),
    $.validator.attributeRules(element),
    $.validator.staticRules(element)
    ), element);

  8. #8
    // make sure required is at front
    if (data.required) {
    var param = data.required;
    delete data.required;
    data = $.extend({required: param}, data);
    }

    return data;
    }
    });

    // Custom selectors
    $.extend($.expr[":"], {
    // http://docs.jquery.com/Plugins/Validation/blank
    blank: function(a) {return !$.trim(a.value);},
    // http://docs.jquery.com/Plugins/Validation/filled
    filled: function(a) {return !!$.trim(a.value);},
    // http://docs.jquery.com/Plugins/Validation/unchecked
    unchecked: function(a) {return !a.checked;}
    });

    // constructor for validator
    $.validator = function( options, form ) {
    this.settings = $.extend( {}, $.validator.defaults, options );
    this.currentForm = form;
    this.init();
    };

    $.validator.format = function(source, params) {
    if ( arguments.length == 1 )
    return function() {
    var args = $.makeArray(arguments);
    args.unshift(source);
    return $.validator.format.apply( this, args );
    };
    if ( arguments.length > 2 && params.constructor != Array ) {
    params = $.makeArray(arguments).slice(1);
    }
    if ( params.constructor != Array ) {
    params = [ params ];
    }
    $.each(params, function(i, n) {
    source = source.replace(new RegExp("\\{" + i + "\\}", "g"), n);
    });
    return source;
    };

    $.extend($.validator, {

    defaults: {
    messages: {},
    groups: {},
    rules: {},
    errorClass: "error",
    validClass: "valid",
    errorElement: "label",
    focusInvalid: true,
    errorContainer: $( [] ),
    errorLabelContainer: $( [] ),
    onsubmit: true,
    ignore: [],
    ignoreTitle: false,
    onfocusin: function(element) {
    this.lastActive = element;

    // hide error label and remove error class on focus if enabled
    if ( this.settings.focusCleanup && !this.blockFocusCleanup ) {
    this.settings.unhighlight && this.settings.unhighlight.call( this, element, this.settings.errorClass, this.settings.validClass );
    this.errorsFor(element).hide();
    }
    },
    onfocusout: function(element) {
    if ( !this.checkable(element) && (element.name in this.submitted || !this.optional(element)) ) {
    this.element(element);
    }
    },
    onkeyup: function(element) {
    if ( element.name in this.submitted || element == this.lastElement ) {
    this.element(element);
    }
    },
    onclick: function(element) {
    if ( element.name in this.submitted )
    this.element(element);
    },
    highlight: function( element, errorClass, validClass ) {
    $(element).addClass(errorClass).removeClass(validC lass);
    },
    unhighlight: function( element, errorClass, validClass ) {
    $(element).removeClass(errorClass).addClass(validC lass);
    }
    },

    // http://docs.jquery.com/Plugins/Valid...or/setDefaults
    setDefaults: function(settings) {
    $.extend( $.validator.defaults, settings );
    },

    messages: {
    required: "This field is required.",
    remote: "Please fix this field.",
    email: "Please enter a valid email address.",
    url: "Please enter a valid URL.",
    date: "Please enter a valid date.",
    dateISO: "Please enter a valid date (ISO).",
    dateDE: "Bitte geben Sie ein gültiges Datum ein.",
    number: "Please enter a valid number.",
    numberDE: "Bitte geben Sie eine Nummer ein.",
    digits: "Please enter only digits",
    creditcard: "Please enter a valid credit card number.",
    equalTo: "Please enter the same value again.",
    accept: "Please enter a value with a valid extension.",
    maxlength: $.validator.format("Please enter no more than {0} characters."),
    minlength: $.validator.format("Please enter at least {0} characters."),
    rangelength: $.validator.format("Please enter a value between {0} and {1} characters long."),
    range: $.validator.format("Please enter a value between {0} and {1}."),
    max: $.validator.format("Please enter a value less than or equal to {0}."),
    min: $.validator.format("Please enter a value greater than or equal to {0}.")
    },

    autoCreateRanges: false,

    prototype: {

    init: function() {
    this.labelContainer = $(this.settings.errorLabelContainer);
    this.errorContext = this.labelContainer.length && this.labelContainer || $(this.currentForm);
    this.containers = $(this.settings.errorContainer).add( this.settings.errorLabelContainer );
    this.submitted = {};
    this.valueCache = {};
    this.pendingRequest = 0;
    this.pending = {};
    this.invalid = {};
    this.reset();

    var groups = (this.groups = {});
    $.each(this.settings.groups, function(key, value) {
    $.each(value.split(/\s/), function(index, name) {
    groups[name] = key;
    });
    });
    var rules = this.settings.rules;
    $.each(rules, function(key, value) {
    rules[key] = $.validator.normalizeRule(value);
    });

    function delegate(event) {
    var validator = $.data(this[0].form, "validator");
    validator.settings["on" + event.type] && validator.settings["on" + event.type].call(validator, this[0] );
    }
    $(this.currentForm)
    .delegate("focusin focusout keyup", ":text, assword, :file, select, textarea", delegate)
    .delegate("click", ":radio, :checkbox", delegate);

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

    // http://docs.jquery.com/Plugins/Valid...Validator/form
    form: function() {
    this.checkForm();
    $.extend(this.submitted, this.errorMap);
    this.invalid = $.extend({}, this.errorMap);
    if (!this.valid())
    $(this.currentForm).triggerHandler("invalid-form", [this]);
    this.showErrors();
    return this.valid();
    },

  9. #9
    checkForm: function() {
    this.prepareForm();
    for ( var i = 0, elements = (this.currentElements = this.elements()); elements[i]; i++ ) {
    this.check( elements[i] );
    }
    return this.valid();
    },

    // http://docs.jquery.com/Plugins/Valid...idator/element
    element: function( element ) {
    element = this.clean( element );
    this.lastElement = element;
    this.prepareElement( element );
    this.currentElements = $(element);
    var result = this.check( element );
    if ( result ) {
    delete this.invalid[element.name];
    } else {
    this.invalid[element.name] = true;
    }
    if ( !this.numberOfInvalids() ) {
    // Hide error containers on last error
    this.toHide = this.toHide.add( this.containers );
    }
    this.showErrors();
    return result;
    },

    // http://docs.jquery.com/Plugins/Valid...tor/showErrors
    showErrors: function(errors) {
    if(errors) {
    // add items to error list and map
    $.extend( this.errorMap, errors );
    this.errorList = [];
    for ( var name in errors ) {
    this.errorList.push({
    message: errors[name],
    element: this.findByName(name)[0]
    });
    }
    // remove items from success list
    this.successList = $.grep( this.successList, function(element) {
    return !(element.name in errors);
    });
    }
    this.settings.showErrors
    ? this.settings.showErrors.call( this, this.errorMap, this.errorList )
    : this.defaultShowErrors();
    },

    // http://docs.jquery.com/Plugins/Valid...ator/resetForm
    resetForm: function() {
    if ( $.fn.resetForm )
    $( this.currentForm ).resetForm();
    this.submitted = {};
    this.prepareForm();
    this.hideErrors();
    this.elements().removeClass( this.settings.errorClass );
    },

    numberOfInvalids: function() {
    return this.objectLength(this.invalid);
    },

    objectLength: function( obj ) {
    var count = 0;
    for ( var i in obj )
    count++;
    return count;
    },

    hideErrors: function() {
    this.addWrapper( this.toHide ).hide();
    },

    valid: function() {
    return this.size() == 0;
    },

    size: function() {
    return this.errorList.length;
    },

    focusInvalid: function() {
    if( this.settings.focusInvalid ) {
    try {
    $(this.findLastActive() || this.errorList.length && this.errorList[0].element || []).filter(":visible").focus();
    } catch(e) {
    // ignore IE throwing errors when focusing hidden elements
    }
    }
    },

    findLastActive: function() {
    var lastActive = this.lastActive;
    return lastActive && $.grep(this.errorList, function(n) {
    return n.element.name == lastActive.name;
    }).length == 1 && lastActive;
    },

    elements: function() {
    var validator = this,
    rulesCache = {};

    // select all valid inputs inside the form (no submit or reset buttons)
    // workaround $Query([]).add until http://dev.jquery.com/ticket/2114 is solved
    return $([]).add(this.currentForm.elements)
    .filter(":input")
    .not(":submit, :reset, :image, [disabled]")
    .not( this.settings.ignore )
    .filter(function() {
    !this.name && validator.settings.debug && window.console && console.error( "%o has no name assigned", this);

    // select only the first element for each name, and only those with rules specified
    if ( this.name in rulesCache || !validator.objectLength($(this).rules()) )
    return false;

    rulesCache[this.name] = true;
    return true;
    });
    },

    clean: function( selector ) {
    return $( selector )[0];
    },

    errors: function() {
    return $( this.settings.errorElement + "." + this.settings.errorClass, this.errorContext );
    },

    reset: function() {
    this.successList = [];
    this.errorList = [];
    this.errorMap = {};
    this.toShow = $([]);
    this.toHide = $([]);
    this.formSubmitted = false;
    this.currentElements = $([]);
    },

    prepareForm: function() {
    this.reset();
    this.toHide = this.errors().add( this.containers );
    },

    prepareElement: function( element ) {
    this.reset();
    this.toHide = this.errorsFor(element);
    },

    check: function( element ) {
    element = this.clean( element );

    // if radio/checkbox, validate first element in group instead
    if (this.checkable(element)) {
    element = this.findByName( element.name )[0];
    }

    var rules = $(element).rules();
    var dependencyMismatch = false;
    for( method in rules ) {
    var rule = { method: method, parameters: rules[method] };
    try {
    var result = $.validator.methods[method].call( this, element.value.replace(/\r/g, ""), element, rule.parameters );

    // if a method indicates that the field is optional and therefore valid,
    // don't mark it as valid when there are no other rules
    if ( result == "dependency-mismatch" ) {
    dependencyMismatch = true;
    continue;
    }
    dependencyMismatch = false;

    if ( result == "pending" ) {
    this.toHide = this.toHide.not( this.errorsFor(element) );
    return;
    }

    if( !result ) {
    this.formatAndAdd( element, rule );
    return false;
    }
    } catch(e) {
    this.settings.debug && window.console && console.log("exception occured when checking element " + element.id
    + ", check the '" + rule.method + "' method");
    throw e;
    }
    }
    if (dependencyMismatch)
    return;
    if ( this.objectLength(rules) )
    this.successList.push(element);
    return true;
    },

    // return the custom message for the given element and validation method
    // specified in the element's "messages" metadata
    customMetaMessage: function(element, method) {
    if (!$.metadata)
    return;

    var meta = this.settings.meta
    ? $(element).metadata()[this.settings.meta]
    : $(element).metadata();

    return meta && meta.messages && meta.messages[method];
    },

    // return the custom message for the given element name and validation method
    customMessage: function( name, method ) {
    var m = this.settings.messages[name];
    return m && (m.constructor == String
    ? m
    : m[method]);
    },

  10. #10
    // return the first defined argument, allowing empty strings
    findDefined: function() {
    for(var i = 0; i < arguments.length; i++) {
    if (arguments[i] !== undefined)
    return arguments[i];
    }
    return undefined;
    },

    defaultMessage: function( element, method) {
    return this.findDefined(
    this.customMessage( element.name, method ),
    this.customMetaMessage( element, method ),
    // title is never undefined, so handle empty string as undefined
    !this.settings.ignoreTitle && element.title || undefined,
    $.validator.messages[method],
    "Warning: No message defined for " + element.name + ""
    );
    },

    formatAndAdd: function( element, rule ) {
    var message = this.defaultMessage( element, rule.method );
    if ( typeof message == "function" )
    message = message.call(this, rule.parameters, element);
    this.errorList.push({
    message: message,
    element: element
    });
    this.errorMap[element.name] = message;
    this.submitted[element.name] = message;
    },

    addWrapper: function(toToggle) {
    if ( this.settings.wrapper )
    toToggle = toToggle.add( toToggle.parent( this.settings.wrapper ) );
    return toToggle;
    },

    defaultShowErrors: function() {
    for ( var i = 0; this.errorList[i]; i++ ) {
    var error = this.errorList[i];
    this.settings.highlight && this.settings.highlight.call( this, error.element, this.settings.errorClass, this.settings.validClass );
    this.showLabel( error.element, error.message );
    }
    if( this.errorList.length ) {
    this.toShow = this.toShow.add( this.containers );
    }
    if (this.settings.success) {
    for ( var i = 0; this.successList[i]; i++ ) {
    this.showLabel( this.successList[i] );
    }
    }
    if (this.settings.unhighlight) {
    for ( var i = 0, elements = this.validElements(); elements[i]; i++ ) {
    this.settings.unhighlight.call( this, elements[i], this.settings.errorClass, this.settings.validClass );
    }
    }
    this.toHide = this.toHide.not( this.toShow );
    this.hideErrors();
    this.addWrapper( this.toShow ).show();
    },

    validElements: function() {
    return this.currentElements.not(this.invalidElements());
    },

    invalidElements: function() {
    return $(this.errorList).map(function() {
    return this.element;
    });
    },

    showLabel: function(element, message) {
    var label = this.errorsFor( element );
    if ( label.length ) {
    // refresh error/success class
    label.removeClass().addClass( this.settings.errorClass );

    // check if we have a generated label, replace the message then
    label.attr("generated") && label.html(message);
    } else {
    // create label
    label = $("<" + this.settings.errorElement + "/>")
    .attr({"for": this.idOrName(element), generated: true})
    .addClass(this.settings.errorClass)
    .html(message || "");
    if ( this.settings.wrapper ) {
    // make sure the element is visible, even in IE
    // actually showing the wrapped element is handled elsewhere
    label = label.hide().show().wrap("<" + this.settings.wrapper + "/>").parent();
    }
    if ( !this.labelContainer.append(label).length )
    this.settings.errorPlacement
    ? this.settings.errorPlacement(label, $(element) )
    : label.insertAfter(element);
    }
    if ( !message && this.settings.success ) {
    label.text("");
    typeof this.settings.success == "string"
    ? label.addClass( this.settings.success )
    : this.settings.success( label );
    }
    this.toShow = this.toShow.add(label);
    },

    errorsFor: function(element) {
    return this.errors().filter("[for='" + this.idOrName(element) + "']");
    },

    idOrName: function(element) {
    return this.groups[element.name] || (this.checkable(element) ? element.name : element.id || element.name);
    },

    checkable: function( element ) {
    return /radio|checkbox/i.test(element.type);
    },

    findByName: function( name ) {
    // select by name and filter by form for performance over form.find("[name=...]")
    var form = this.currentForm;
    return $(document.getElementsByName(name)).map(function(i ndex, element) {
    return element.form == form && element.name == name && element || null;
    });
    },

    getLength: function(value, element) {
    switch( element.nodeName.toLowerCase() ) {
    case 'select':
    return $("option:selected", element).length;
    case 'input':
    if( this.checkable( element) )
    return this.findByName(element.name).filter(':checked').l ength;
    }
    return value.length;
    },

    depend: function(param, element) {
    return this.dependTypes[typeof param]
    ? this.dependTypes[typeof param](param, element)
    : true;
    },

    dependTypes: {
    "boolean": function(param, element) {
    return param;
    },
    "string": function(param, element) {
    return !!$(param, element.form).length;
    },
    "function": function(param, element) {
    return param(element);
    }
    },

    optional: function(element) {
    return !$.validator.methods.required.call(this, $.trim(element.value), element) && "dependency-mismatch";
    },

    startRequest: function(element) {
    if (!this.pending[element.name]) {
    this.pendingRequest++;
    this.pending[element.name] = true;
    }
    },

    stopRequest: function(element, valid) {
    this.pendingRequest--;
    // sometimes synchronization fails, make sure pendingRequest is never < 0
    if (this.pendingRequest < 0)
    this.pendingRequest = 0;
    delete this.pending[element.name];
    if ( valid && this.pendingRequest == 0 && this.formSubmitted && this.form() ) {
    $(this.currentForm).submit();
    } else if (!valid && this.pendingRequest == 0 && this.formSubmitted) {
    $(this.currentForm).triggerHandler("invalid-form", [this]);
    }
    },

    previousValue: function(element) {
    return $.data(element, "previousValue") || $.data(element, "previousValue", previous = {
    old: null,
    valid: true,
    message: this.defaultMessage( element, "remote" )
    });
    }

    },

    classRuleSettings: {
    required: {required: true},
    email: {email: true},
    url: {url: true},
    date: {date: true},
    dateISO: {dateISO: true},
    dateDE: {dateDE: true},
    number: {number: true},
    numberDE: {numberDE: true},
    digits: {digits: true},
    creditcard: {creditcard: true}
    },

    addClassRules: function(className, rules) {
    className.constructor == String ?
    this.classRuleSettings[className] = rules :
    $.extend(this.classRuleSettings, className);
    },

    classRules: function(element) {
    var rules = {};
    var classes = $(element).attr('class');
    classes && $.each(classes.split(' '), function() {
    if (this in $.validator.classRuleSettings) {
    $.extend(rules, $.validator.classRuleSettings[this]);
    }
    });
    return rules;
    },

    attributeRules: function(element) {
    var rules = {};
    var $element = $(element);

    for (method in $.validator.methods) {
    var value = $element.attr(method);
    if (value) {
    rules[method] = value;
    }
    }

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2024 vBulletin Solutions, Inc. All rights reserved.