/* =============================================
Author:			James Cavendish
Create Date:	2008
Description:	Validation functions used for input controls

Copyright:		(C) 2009 Askaprice.com LLP. 
Unauthorised modification or distribution is strictly prohibited. All rights reserved.

WARNING:		This file was generated by code and gets overwritten with the copy from the Web DLL.
============================================= */

/*
1 = No Numeric
2 = No Alpha
4 = Not Negative
8 = Percent
16 = NoSpecial
32 = NoSpace
*/


function validateInput(e, validationOptions)
{
    var charCode;

    if (!e) { var e = window.event; }

    if (e.keyCode) { charCode = e.keyCode; }
    else if (e.which) { charCode = e.which; }

    var targ;

    if (e.target) { targ = e.target; }
    else if (e.srcElement) { targ = e.srcElement; }
    if (targ.nodeType == 3) // defeat Safari bug
    {
        targ = targ.parentNode;
    }

    if (charCode == 8 || charCode == 39 || charCode == 37 || charCode == 9)
    {
        return;
    }

    var txt = new String();
    var output = new String();
    var charString = new String();
    var foundDecimal = -1;

    txt = targ.value;

    for (var i = 0; i < txt.length; i++)
    {
        charString = txt.charAt(i);
        charCode = txt.charCodeAt(i);
        //perform relevant validation

        //No Alpha Characters
        if ((validationOptions & 2) == 2)
        {
            if ((charCode > 64 && charCode < 91) ||
                    (charCode > 96 && charCode < 123))
            {
                continue;
            }
        }

        //No Numeric Characters
        if ((validationOptions & 1) == 1)
        {
            if ((charCode > 47 && charCode < 58))
            {
                continue;
            }
        }

        //No Space Characters
        if ((validationOptions & 32) == 32)
        {
            if (charCode == 32)
            {
                continue;
            }
        }

        //No Special Characters (Except . space and -)
        if ((validationOptions & 16) == 16)
        {
            if ((charCode > 32 && charCode < 44) ||
                    (charCode > 57 && charCode < 65) ||
                    (charCode > 90 && charCode < 97) ||
                    (charCode > 122 && charCode < 127) ||
                    charCode == 47)
            {
                continue;
            }
        }

        if (foundDecimal > -1)
        {
            foundDecimal++;
        }

        if (charString == "." && foundDecimal == -1 && (validationOptions & 2) == 2)
        {
            foundDecimal = 0;
        }

        if (charString == '-' && i === 0 && (validationOptions & 4) == 4)
        {
            continue;
        }

        if (foundDecimal > 2)
        {
            continue;
        }

        output = output + charString;
    }

    if ((validationOptions & 8) == 8)
    {
        if (((Number)(output)) > 100)
        {
            output = "100";
        }
    }
    if (output != targ.value)
    {
        targ.value = output;
    }

}




function checkValidPostCode(toCheck)
{

    // Permitted letters depend upon their position in the postcode.
    var alpha1 = "[abcdefghijklmnoprstuwyz]";                       // Character 1
    var alpha2 = "[abcdefghklmnopqrstuvwxy]";                       // Character 2
    var alpha3 = "[abcdefghjkstuw]";                                // Character 3
    var alpha4 = "[abehmnprvwxy]";                                  // Character 4
    var alpha5 = "[abdefghjlnpqrstuwxyz]";                          // Character 5

    // Array holds the regular expressions for the valid postcodes
    var pcexp = new Array();

    // Expression for postcodes: AN NAA, ANN NAA, AAN NAA, and AANN NAA
    pcexp.push(new RegExp("^(" + alpha1 + "{1}" + alpha2 + "?[0-9]{1,2})(\\s*)([0-9]{1}" + alpha5 + "{2})$", "i"));

    // Expression for postcodes: ANA NAA
    pcexp.push(new RegExp("^(" + alpha1 + "{1}[0-9]{1}" + alpha3 + "{1})(\\s*)([0-9]{1}" + alpha5 + "{2})$", "i"));

    // Expression for postcodes: AANA  NAA
    pcexp.push(new RegExp("^(" + alpha1 + "{1}" + alpha2 + "?[0-9]{1}" + alpha4 + "{1})(\\s*)([0-9]{1}" + alpha5 + "{2})$", "i"));

    // Exception for the special postcode GIR 0AA
    pcexp.push(/^(GIR)(\s*)(0AA)$/i);

    // Standard BFPO numbers
    pcexp.push(/^(bfpo)(\s*)([0-9]{1,4})$/i);

    // c/o BFPO numbers
    pcexp.push(/^(bfpo)(\s*)(c\/o\s*[0-9]{1,3})$/i);

    // Overseas Territories
    pcexp.push(/^([A-Z]{4})(\s*)(1ZZ)$/i);

    // Load up the string to check
    var postCode = toCheck;

    // Assume we're not going to find a valid postcode
    var valid = false;

    // Check the string against the types of post codes
    for (var i = 0; i < pcexp.length; i++)
    {
        if (pcexp[i].test(postCode))
        {

            // The post code is valid - split the post code into component parts
            pcexp[i].exec(postCode);

            // Copy it back into the original string, converting it to uppercase and
            // inserting a space between the inward and outward codes
            postCode = RegExp.$1.toUpperCase() + " " + RegExp.$3.toUpperCase();

            // If it is a BFPO c/o type postcode, tidy up the "c/o" part
            postCode = postCode.replace(/C\/O\s*/, "c/o ");

            // Load new postcode back into the form element
            valid = true;

            // Remember that we have found that the code is valid and break from loop
            break;
        }
    }

    // Return with either the reformatted valid postcode or the original invalid 
    // postcode
    if (valid) { return postCode; } else { return false; }
}