/* 
* Validation rules specification. Keys refere to ASP controls IDs. 
*/
validationPatterns = {
    postCode: /^[1-9][0-9]{3}([0-9]|[a-z]{2})?$/i,
    incompletePostCode: /^\d{1}\d* ?[A-Z]?$/i,
    houseNumber: /^[\w\-\/ ]+$/,
    houseNumberAddition: /^[\w\-\/ ]+$/,
    price: /^(\d{1,3}(\.\d{3}){0,2}|(\d{1,10}))$/,
    phoneNumber: /^[0-9\(\)\+\-\s]+$/,
    password: /^(?=[\w@#$%^&]{6,})(?=.*?\d{2})(?=.*?[a-z]{2})[\w@#$%^&]*$/i
};

validationRules = {
    // L15
    tboxL15PostCode: {
        required: true,
        regex: validationPatterns.postCode
    },
    tboxL15HouseNumber: {
        required: true,
        regex: validationPatterns.houseNumber
    },
    tboxL15HouseNumberAddition: {
        regex: validationPatterns.houseNumberAddition
    },
    tboxL15PhoneNumber: {
        required: true,
        regex: validationPatterns.phoneNumber
    },

	// L11
    txtL11lightboxZipCode: {
        required: true,
        regex: validationPatterns.postCode
    },
    txtL11lightboxHouseNumber: {
        required: true,
        regex: validationPatterns.houseNumber
    },
    txtL11lightboxHouseNumberAddition: {
        regex: validationPatterns.houseNumberAddition
    },
	
    // L18
    tboxL18PostCode: {
        required: true,
        regex: validationPatterns.postCode
    },
    tboxL18HouseNumber: {
        required: true,
        regex: validationPatterns.houseNumber
    },
    tboxL18HouseNumberAddition: {
        regex: validationPatterns.houseNumberAddition
    },
	
    // L26
    txtL23L26StreetZip: {
        required: true,
        notregex:validationPatterns.incompletePostCode
    },
    txtL23L26HouseNumber: {
        required: false,
        regex: validationPatterns.houseNumber
    },
    txtL23L26NumberAddition: {
        regex: validationPatterns.houseNumberAddition
    },
    txtL23L26Place: {
        required: function(element) {
            //regex that validates postcode. Valid: 1234 AB and 1234AB
            postCodeRe = /^[1-9]{1}[0-9]{3} ?[A-Z]{2}$/i;
            streetZip = $('input[id$=txtL23L26StreetZip]').val();
            return !postCodeRe.test(streetZip);
        }
    },

    // L26_widget
    txtL26WidgetStreetZip: {
        required: true,
        notregex: validationPatterns.incompletePostCode
        
    },
    txtL26WidgetHouseNumber: {
        required: false,
        regex: validationPatterns.houseNumber
    },
    txtL26WidgetPlace: {
        required: function(element) {
            //regex that validates postcode. Valid: 1234 AB and 1234AB
            postCodeRe = /^[1-9]{1}[0-9]{3} ?[A-Z]{2}$/i;
            streetZip = $('input[id$=txtL26WidgetStreetZip]').val();
            return !postCodeRe.test(streetZip);
        }
    },
	
    // C2
    tboxC2ZipCode: {
        regex: validationPatterns.postCode
    },
    tboxC2HouseNumber: {
        regex: validationPatterns.houseNumber
    },
    // C2.1
    tboxC2_1ZipCode: {
        regex: validationPatterns.postCode
    },
    tboxC2_1HouseNumber: {
        regex: validationPatterns.houseNumber
    },
    tboxC2_1HouseNumberAddition: {
        regex: validationPatterns.houseNumberAddition
    },
    tboxC2_1AskingPrice: {
        regex: validationPatterns.price
    },
    // C2.2
    tboxC2_2ZipCode: {
        regex: validationPatterns.postCode
    },
    tboxC2_2HouseNumber: {
        regex: validationPatterns.houseNumber
    },
    tboxC2_2HouseNumberAddition: {
        regex: validationPatterns.houseNumberAddition
    },
    tboxC2_2AskingPrice: {
        regex: validationPatterns.price
    },
    tboxC2_2DesiredPrice: {
        regex: validationPatterns.price
    },
    // C3
    tboxC3FirstName: {
        required: true
    },
    tboxC3LastName: {
        required: true
    },
    C3Gender: {
        required: true
    },
    tboxC3EmailAddress: {
        required: true,
        email: true,
        remote: {
            async: false,
            type: 'POST',
            url: '/_vti_bin/PortalValidationService.asmx/IsNotUsedEmailAddress',
            execData: function() {
                var self = this;
                return JSON.stringify({
                    emailAddress: $(self).val()
                });
            },
            dataFilter: function(data, type) {
                data = JSON.parse(data);
                return data.d;
            },
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        }
    },
    tboxC3PhoneNumber: {
        required: true,
        regex: validationPatterns.phoneNumber
    },
    tboxC3_1Day: {
        trigger: 'input[name$=tboxC3_1Year]'
    },
    ddlC3_1Month: {
        trigger: 'input[name$=tboxC3_1Year]'
    },
    tboxC3_1Year: {
        validDate: {
            day: 'input[name$=tboxC3_1Day]',
            month: 'select[name$=ddlC3_1Month]',
            year: 'input[name$=tboxC3_1Year]'
        }
    },
    // C4
    tboxC4Password: {
        required: true,
        regex: validationPatterns.password
    },
    tboxC4RetypePassword: {
        equalTo: 'input[name$=tboxC4Password]'
    },
    // C5
    C5SendBy: {
        required: function(element) {
            return $('input[name$=chkC5ContactMe2]:checked', $(element).parents('.logical-form')).size() > 0;
        }
    },
    tboxC5ZipCode1: {
        required: function(element) {
            return $('input[id$=radioC5SendByPost]:checked', $(element).parents('.logical-form')).size() > 0;
        },
        regex: validationPatterns.postCode
    },
    tboxC5HouseNumber1: {
        required: function(element) {
            return $('input[id$=radioC5SendByPost]:checked', $(element).parents('.logical-form')).size() > 0;
        },
        regex: validationPatterns.houseNumber
    },
    tboxC5ZipCode2: {
        required: function(element) {
            return $('input[name$=chkC5ContactMe3]:checked', $(element).parents('.logical-form')).size() > 0;
        },
        regex: validationPatterns.postCode
    },
    tboxC5HouseNumber2: {
        required: function(element) {
            return $('input[name$=chkC5ContactMe3]:checked', $(element).parents('.logical-form')).size() > 0;
        },
        regex: validationPatterns.houseNumber
    },
    ddlC5AppointmentOffice: {
        required: function(element) {
            return $('input[name$=chkC5ContactMe4]:checked', $(element).parents('.logical-form')).size() > 0;
        }
    },

    // P54
    tboxP54ZipCode: {
        required: true,
        regex: validationPatterns.postCode,
        validP54address: {
            postCode: 'input[name$=tboxP54ZipCode]',
            houseNumber: 'input[name$=tboxP54HouseNumber]',
            manualAddress: 'input[name$=cbP54ManualStreetCity]',
            street: 'input[name$=txtP54Street]',
            city: 'input[name$=txtP54City]',
            streetLabel: '.p54-streetname',
            cityLabel: '.p54-cityname'
        }
    },

    tboxP54HouseNumber: {
        required: true,
        regex: validationPatterns.houseNumber,
        trigger: 'input[name$=tboxP54ZipCode]'
    },

    txtP54Street: {
        required: 'input[name$=cbP54ManualStreetCity]:checked'
    },

    txtP54City: {
        required: 'input[name$=cbP54ManualStreetCity]:checked'
    },

    // C7
    tboxC7EmailAddress: {
        required: true,
        email: true,
        remote: {
            async: false,
            type: 'POST',
            url: '/_vti_bin/PortalValidationService.asmx/IsNotUsedEmailAddress',
            execData: function() {
                var self = this;
                return JSON.stringify({
                    emailAddress: $(self).val()
                });
            },
            dataFilter: function(data, type) {
                data = JSON.parse(data);
                return data.d;
            },
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        }
    },

    // L73
    tboxL73DOB_Day: {
        trigger: 'input[name$=tboxL73DOB_Year]'
    },
    ddlL73DOB_Month: {
        trigger: 'input[name$=tboxL73DOB_Year]'
    },
    tboxL73DOB_Year: {
        validDate: {
            day: 'input[name$=tboxL73DOB_Day]',
            month: 'select[name$=ddlL73DOB_Month]',
            year: 'input[name$=tboxL73DOB_Year]'
        },
        remote: {
            onsubmit: true,
            forceCheck: true,
            async: false,
            type: 'POST',
            url: '/_vti_bin/PortalValidationService.asmx/ValidateContactEmailAndBirthCombination',
            execData: function() {
                var self = this;
                return JSON.stringify({
                    email: $(self).parents('fieldset').find('input[name$=tboxL73EmailAddress]').val(),
                    day: parseInt($(self).parents('fieldset').find('input[name$=tboxL73DOB_Day]').val(), 10),
                    month: parseInt($(self).parents('fieldset').find('select[name$=ddlL73DOB_Month]').val()),
                    year: parseInt($(self).parents('fieldset').find('input[name$=tboxL73DOB_Year]').val())
                });
            },
            dataFilter: function(data, type) {
                data = JSON.parse(data);
                var result = false;
                switch (data.d) {
                    case 'InvalidCombination': result = 'Deze geboorte-datum is niet correct in combinatie met dit e-mail adres';
                        break;
                    case 'UnknownEmail': result = ' ';
                        break;
                    case 'Success': result = true;
                        break;
                }
                result = JSON.stringify(result);
                return result;
            },
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        }
    },
    tboxL73EmailAddress: {
        required: true,
        email: true,
        remote: {
            onsubmit: true,
            forceCheck: true,
            async: false,
            type: 'POST',
            url: '/_vti_bin/PortalValidationService.asmx/ValidateContactEmailAndBirthCombination',
            execData: function() {
                var self = this;
                return JSON.stringify({
                    email: $(self).val(),
                    day: parseInt($(self).parents('fieldset').find('input[name$=tboxL73DOB_Day]').val()),
                    month: parseInt($(self).parents('fieldset').find('select[name$=ddlL73DOB_Month]').val()),
                    year: parseInt($(self).parents('fieldset').find('input[name$=tboxL73DOB_Year]').val())
                });
            },
            dataFilter: function(data, type) {
                data = JSON.parse(data);
                var result = false;
                switch (data.d) {
                    case 'InvalidCombination': result = ' ';
                        break;
                    case 'UnknownEmail': result = 'Dit emailadres is onbekend';
                        break;
                    case 'Success': result = true;
                        break;
                }
                result = JSON.stringify(result);
                return result;
            },
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        }
    },

    // C19
    tboxC19FirstName: {
        required: true
    },
    tboxC19LastName: {
        required: true
    },
    C19Gender: {
        required: true
    },
    tboxC19DOB_Day: {
        trigger: 'input[name$=tboxC19DOB_Year]'
    },
    ddlC19DOB_Month: {
        trigger: 'input[name$=tboxC19DOB_Year]'
    },
    tboxC19DOB_Year: {
        validDate: {
            day: 'input[name$=tboxC19DOB_Day]',
            month: 'select[name$=ddlC19DOB_Month]',
            year: 'input[name$=tboxC19DOB_Year]'
        }
    },
    tboxC19Email: {
        required: true,
        email: true,
        remote: {
            onsubmit: true,
            syncProcess: true,
            forceCheck: true,
            async: false,
            type: 'POST',
            url: '/_vti_bin/PortalValidationService.asmx/IsNotUsedActiveInactiveEmailAddress',
            execData: function() {
                var self = this;
                return JSON.stringify({
                    emailAddress: $(self).val()
                });
            },
            dataFilter: function(data, type) {
                data = JSON.parse(data);
                //(window.console && console.log('IsNotUsedActiveInactiveEmailAddress', data));
                return data.d;
            },
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        }
    },
    tboxC19PhoneNumber1: {
        required: true,
        regex: validationPatterns.phoneNumber
    },
    tboxC19PhoneNumber2: {
        regex: validationPatterns.phoneNumber
    },
    // C20
    tboxC20PartnerFirstName: {
        required: 'input[name$=chkC20Partner]:checked'
    },
    tboxC20PartnerLastName: {
        required: 'input[name$=chkC20Partner]:checked'
    },
    C20Gender: {
        required: 'input[name$=chkC20Partner]:checked'
    },
    tboxC20PartnerDOB_Day: {
        trigger: '*[name$=tboxC20PartnerDOB_Year]'
    },
    ddlC20PartnerDOB_Month: {
        trigger: '*[name$=tboxC20PartnerDOB_Year]'
    },
    tboxC20PartnerDOB_Year: {
        validDate: {
            day: '*[name$=tboxC20PartnerDOB_Day]',
            month: '*[name$=ddlC20PartnerDOB_Month]',
            year: '*[name$=tboxC20PartnerDOB_Year]',
            required: 'input[name$=chkC20Partner]:checked'
        }
    },
    tboxC20PartnerEmail: {
        email: true,
        remote: {
            syncProcess: true,
            async: false,
            type: 'POST',
            url: '/_vti_bin/PortalValidationService.asmx/IsNotUsedEmailAddress',
            execData: function() {
                var self = this;
                return JSON.stringify({
                    emailAddress: $(self).val()
                });
            },
            dataFilter: function(data, type) {
                data = JSON.parse(data);
                return data.d;
            },
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        }
    },
    tboxC20PartnerPhoneNumber1: {
        regex: validationPatterns.phoneNumber
    },
    tboxC20PartnerPhoneNumber2: {
        regex: validationPatterns.phoneNumber
    },
    tboxC20PartnerCurrentAddressZipCode: {
        required: false,
        regex: validationPatterns.postCode
    },

    // C21
    tboxC21CurrentPassword: {
        required: true,
        remote: {
            async: false,
            type: 'POST',
            url: '/_vti_bin/PortalValidationService.asmx/IsValidCurrentPassword',
            execData: function() {
                var self = this;
                return JSON.stringify({
                    password: $(self).val()
                });
            },
            dataFilter: function(data, type) {
                data = JSON.parse(data);
                return data.d;
            },
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        }
    },
    tboxC21NewPassword: {
        required: true,
        regex: validationPatterns.password
    },
    tboxC21RetypeNewPassword: {
        equalTo: 'input[name$=tboxC21NewPassword]'
    },

    // C22
    C22StartPage: {
        required: true
    },

    // L62
    tboxL62LoginUsername: {
        required: true,
        remote: {
            onsubmit: true,
            forceCheck: true,
            async: false,
            type: 'POST',
            url: '/_vti_bin/PortalValidationService.asmx/ValidateLogin',
            execData: function() {
                var self = this;
                return JSON.stringify({
                    username: $(self).val(),
                    password: $(self).parents('fieldset').find('input[name$=tboxL62LoginPassword]').val()
                });
            },
            dataFilter: function(data, type) {
                data = JSON.parse(data);
                var result = false;
                switch (data.d) {
                    case 'UnknownUsername': result = 'De inlognaam is niet bekend';
                        break;
                    case 'NotActive': result = 'Activeer uw account met de link in uw welkomst e-mail';
                        break;
                    case 'InvalidLogin': result = '';
                        break;
                    case 'Success': result = true;
                        break;
                }
                result = JSON.stringify(result);
                return result;
            },
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        }
    },
    tboxL62LoginPassword: {
        required: true,
        remote: {
            onsubmit: true,
            forceCheck: true,
            async: false,
            type: 'POST',
            url: '/_vti_bin/PortalValidationService.asmx/ValidateLogin',
            execData: function() {
                var self = this;
                return JSON.stringify({
                    username: $(self).parents('fieldset').find('input[name$=tboxL62LoginUsername]').val(),
                    password: $(self).val()
                });
            },
            dataFilter: function(data, type) {
                data = JSON.parse(data);
                var result = false;
                switch (data.d) {
                    case 'UnknownUsername': result = '';
                        break;
                    case 'NotActive': result = '';
                        break;
                    case 'InvalidLogin': result = 'Het wachtwoord is onjuist';
                        break;
                    case 'Success': result = true;
                        break;
                }
                result = JSON.stringify(result);
                return result;
            },
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        }
    },
    tboxL62SignUpEmailAddress: {
        required: true,
        email: true,
        remote: {
            async: false,
            type: 'POST',
            url: '/_vti_bin/PortalValidationService.asmx/IsNotUsedEmailAddress',
            execData: function() {
                var self = this;
                return JSON.stringify({
                    emailAddress: $(self).val()
                });
            },
            dataFilter: function(data, type) {
                data = JSON.parse(data);
                return data.d;
            },
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        }
    },
    tboxL62SignUpPassword: {
        required: true,
        regex: validationPatterns.password
    },
    tboxL62SignUpRetypePassword: {
        equalTo: 'input[name$=tboxL62SignUpPassword]'
    },

    // L2
    tboxL2LoginName: {
        required: true,
        remote: {
            onsubmit: true,
            forceCheck: true,
            async: false,
            type: 'POST',
            url: '/_vti_bin/PortalValidationService.asmx/ValidateLogin',
            execData: function() {
                var self = this;
                return JSON.stringify({
                    username: $(self).val(),
                    password: $(self).parents('.wpLogin').find('input[name$=tboxL2Password]').val()
                });
            },
            dataFilter: function(data, type) {
                data = JSON.parse(data);
                var result = false;
                switch (data.d) {
                    case 'UnknownUsername': result = 'De inlognaam is niet bekend';
                        break;
                    case 'NotActive': result = 'Activeer uw account met de link in uw welkomst e-mail';
                        break;
                    case 'InvalidLogin': result = '';
                        break;
                    case 'Success': result = true;
                        break;
                }
                result = JSON.stringify(result);
                return result;
            },
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        }
    },
    tboxL2Password: {
        required: true,
        remote: {
            onsubmit: true,
            forceCheck: true,
            async: false,
            type: 'POST',
            url: '/_vti_bin/PortalValidationService.asmx/ValidateLogin',
            execData: function() {
                var self = this;
                return JSON.stringify({
                    username: $(self).parents('.wpLogin').find('input[name$=tboxL2LoginName]').val(),
                    password: $(self).val()
                });
            },
            dataFilter: function(data, type) {
                data = JSON.parse(data);
                var result = false;
                switch (data.d) {
                    case 'UnknownUsername': result = '';
                        break;
                    case 'NotActive': result = '';
                        break;
                    case 'InvalidLogin': result = 'Het wachtwoord is onjuist';
                        //(window.console && console.log('InvalidLogin'));
                        break;
                    case 'Success': result = true;
                        break;
                }
                result = JSON.stringify(result);
                return result;
            },
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        }
    },

    // L68
    tboxL68PhoneNumber: {
        required: true,
        regex: validationPatterns.phoneNumber
    },

    // L74
    tboxL74Password: {
        required: true,
        regex: validationPatterns.password
    },
    tboxL74RetypePassword: {
        equalTo: 'input[name$=tboxL74Password]'
    },

    // A39
    tboxA39ZipCode: {
        required: true,
        regex: validationPatterns.postCode
    },
    tboxA39HouseNumber: {
        required: true,
        regex: validationPatterns.houseNumber
    },
    tboxA39PhoneNumber: {
        required: true,
        regex: validationPatterns.phoneNumber
    },

    // V1
    tboxV1ZipCode: {
        required: true,
        regex: validationPatterns.postCode
    },
    tboxV1HouseNumber: {
        required: true,
        regex: validationPatterns.houseNumber
    },

	// V24
    ddlV24AppointmentFromHour: {
        trigger: 'select[name$=ddlV24AppointmentTilMinute]'
    },

    ddlV24AppointmentFromMinute: {
        trigger: 'select[name$=ddlV24AppointmentTilMinute]'
    },

    ddlV24AppointmentTilHour: {
        trigger: 'select[name$=ddlV24AppointmentTilMinute]'
    },

    ddlV24AppointmentTilMinute: {
        validTime: {
            fromHour: 'select[name$=ddlV24AppointmentFromHour]',
            fromMinute: 'select[name$=ddlV24AppointmentFromMinute]',
            tilHour: 'select[name$=ddlV24AppointmentTilHour]',
            tilMinute: 'select[name$=ddlV24AppointmentTilMinute]'
        }
    },

	// V23/V25
    ddlV23V25AppointmentFromHour: {
        trigger: 'select[name$=ddlV23V25AppointmentTilMinute]'
    },

    ddlV23V25AppointmentFromMinute: {
        trigger: 'select[name$=ddlV23V25AppointmentTilMinute]'
    },

    ddlV23V25AppointmentTilHour: {
        trigger: 'select[name$=ddlV23V25AppointmentTilMinute]'
    },

    ddlV23V25AppointmentTilMinute: {
        validTime: {
            fromHour: 'select[name$=ddlV23V25AppointmentFromHour]',
            fromMinute: 'select[name$=ddlV23V25AppointmentFromMinute]',
            tilHour: 'select[name$=ddlV23V25AppointmentTilHour]',
            tilMinute: 'select[name$=ddlV23V25AppointmentTilMinute]'
        }
    },

	// V26
    ddlV26_1AppointmentFromHour: {
        trigger: 'select[name$=ddlV26_1AppointmentTilMinute]'
    },

    ddlV26_1AppointmentFromMinute: {
        trigger: 'select[name$=ddlV26_1AppointmentTilMinute]'
    },

    ddlV26_1AppointmentTilHour: {
        trigger: 'select[name$=ddlV26_1AppointmentTilMinute]'
    },

    ddlV26_1AppointmentTilMinute: {
        validTime: {
            fromHour: 'select[name$=ddlV26_1AppointmentFromHour]',
            fromMinute: 'select[name$=ddlV26_1AppointmentFromMinute]',
            tilHour: 'select[name$=ddlV26_1AppointmentTilHour]',
            tilMinute: 'select[name$=ddlV26_1AppointmentTilMinute]'
        }
    },

    // M52
    tboxM52LoginEmail: {
        required: true,
        remote: {
            onsubmit: true,
            forceCheck: true,
            async: false,
            type: 'POST',
            url: '/_vti_bin/PortalValidationService.asmx/ValidateLogin',
            execData: function() {
                var self = this;
                return JSON.stringify({
                    username: $(self).val(),
                    password: $(self).parents('.logical-form').find('input[name$=tboxM52LoginEmailPassword]').val()
                });
            },
            dataFilter: function(data, type) {
                data = JSON.parse(data);
                var result = false;
                switch (data.d) {
                    case 'UnknownUsername': result = 'De inlognaam is niet bekend';
                        break;
                    case 'NotActive': result = 'Activeer uw account met de link in uw welkomst e-mail';
                        break;
                    case 'InvalidLogin': result = '';
                        break;
                    case 'Success': result = true;
                        break;
                }
                result = JSON.stringify(result);
                return result;
            },
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        }
    },
    tboxM52LoginEmailPassword: {
        required: true,
        remote: {
            onsubmit: true,
            forceCheck: true,
            async: false,
            type: 'POST',
            url: '/_vti_bin/PortalValidationService.asmx/ValidateLogin',
            execData: function() {
                var self = this;
                return JSON.stringify({
                    username: $(self).parents('.logical-form').find('input[name$=tboxM52LoginEmail]').val(),
                    password: $(self).val()
                });
            },
            dataFilter: function(data, type) {
                data = JSON.parse(data);
                var result = false;
                switch (data.d) {
                    case 'UnknownUsername': result = '';
                        break;
                    case 'NotActive': result = '';
                        break;
                    case 'InvalidLogin': result = 'Het wachtwoord is onjuist';
                        break;
                    case 'Success': result = true;
                        break;
                }
                result = JSON.stringify(result);
                return result;
            },
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        }
    },
    tboxM52RegisterEmail: {
        required: true,
        email: true,
        remote: {
            async: false,
            type: 'POST',
            url: '/_vti_bin/PortalValidationService.asmx/IsNotUsedEmailAddress',
            execData: function() {
                var self = this;
                return JSON.stringify({
                    emailAddress: $(self).val()
                });
            },
            dataFilter: function(data, type) {
                data = JSON.parse(data);
                return data.d;
            },
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        }
    },
    tboxM52RegisterPassword: {
        required: true,
        regex: validationPatterns.password
    },
    tboxM52RegisterConfirmPassword: {
        equalTo: 'input[name$=tboxM52RegisterPassword]'
    },
    chkM52GeneralConditions: {
        required: function(element) {
            var logicalForm = $(element).parents('.logical-form');
            if ($('input[name$=tboxM52RegisterEmail]', logicalForm).val() != '' ||
					$('input[name$=tboxM52RegisterPassword]', logicalForm).val() != '' ||
					$('input[name$=tboxM52RegisterConfirmPassword]', logicalForm).val() != '') {
                return true;
            }
            return false;
        }
    },

    //M46
    tboxM46EmailAddress1: {
        required: function(element) {
            var logicalForm = $(element).parents('.logical-form');
            if (logicalForm.find('input[name$=chkMailing]:checked').size() == 1) {
                if ((logicalForm.find('input[name$=chkM46EmailAddress1]:checked').size() == 1) ||
					(logicalForm.find('input[name$=chkM46EmailAddress2]:checked').size() == 0)) return true;
            }
            return false;
        },
        email: true
    },

    tboxM46EmailAddress2: {
        required: function(element) {
            var logicalForm = $(element).parents('.logical-form');
            if (logicalForm.find('input[name$=chkMailing]:checked').size() == 1) {
                if (logicalForm.find('input[name$=chkM46EmailAddress2]:checked').size() == 1) return true;
            }
            return false;
        },
        email: true
    },

    //M38.1
    tboxM38_1EmailAddress1: {
        required: function(element) {
            var logicalForm = $(element).parents('.logical-form');
            if (logicalForm.find('input[name$=chkM38_1EmailAddress1]:checked').size() == 1)
                return true;
            return false;
        },
        email: true
    },

    tboxM38_1EmailAddress2: {
        required: function(element) {
            var logicalForm = $(element).parents('.logical-form');
            if (logicalForm.find('input[name$=chkM38_1EmailAddress2]:checked').size() == 1)
                return true;
            return false;
        },
        email: true
    },

    // A50
    tboxNameTogether: {
        required: true
    },
    tboxEmailTogether: {
        required: true,
        email: true
    },
    tboxPhoneNoTogether: {
        required: true,
        regex: validationPatterns.phoneNumber
    },
    tboxOfferStep2: {
        required: true
    },
    tboxNameStep2: {
        required: true
    },
    tboxEmailStep2: {
        required: true,
        email: true
    },
    tboxPhoneNoStep2: {
        required: true,
        regex: validationPatterns.phoneNumber
    },
    tboxMyBidToDate: {
        required: true
    },
    tboxTransferDate: {
        required: true
    },
    
    //A44.2
    tboxType1235Date: {
        required: true
    },    
    tboxType125Name: {
        required: true
    },
    tboxType125Email: {
        required: true,
        email: true
    },
    tboxType125Telephone: {
        required: true,
        regex: validationPatterns.phoneNumber
    },
    

    //A44.3
    tboxA44_3_ShipToZipcode: {
        required: true,
        regex: validationPatterns.postCode
    },
    tboxA44_3_ShipToHouseNr: {
        required: true,
        regex: validationPatterns.houseNumber
    },
    tboxA44_3_ShipToCity: {
        required: true
    },

    //M51
    tboxM51Email: {
        required: true,
        email: true,
        remote: {
            async: false,
            type: 'POST',
            url: '/_vti_bin/PortalValidationService.asmx/IsNotUsedEmailAddress',
            execData: function() {
                var self = this;
                return JSON.stringify({
                    emailAddress: $(self).val()
                });
            },
            dataFilter: function(data, type) {
                data = JSON.parse(data);
                return data.d;
            },
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        }
    },
    tboxM51Password: {
        required: true,
        regex: validationPatterns.password
    },
    tboxM51RetypePassword: {
        equalTo: 'input[name$=tboxM51Password]'
    },

    // N43
    tboxN43YourName: {
        required: true
    },
    tboxN43EmailAddress: {
        required: true,
        email: true
    },
    tboxN43AreaQuestion: {
        required: true
    },
    tboxN43PhoneNumber: {
        required: function(element) {
            return ($('input[id$=radioN43HowToContactPhoneNumber]')[0].checked || $('input[id$=radioN43HowToContactByMakingAnAppointment]')[0].checked);
        },
        regex: validationPatterns.phoneNumber
    },

    //N9
    txtN9AccountName: {
        required: true
    },
    txtN9AccountNumber: {
        required: true,
        validAccountNumber: true
    },
    txtN9City: {
        required: true
    },
	
	// N17
    txtN17Name: {
        required: true
    },
    txtN17Email: {
        required: true,
        email: true
    },
	txtN17Question: {
		required: true
	},
	txtN17Phone: {
        required: function(element) {
            return $('input[id$=rbtnN17Phone]')[0].checked;
        },
        regex: validationPatterns.phoneNumber
	}
	
};

/* 
* Validation rules error messages. They have to match validation rules exactly.
*/
validationMessages = {
    // L15
    tboxL15PostCode: {
        required: 'Vul een geldige postcode in',
        regex: 'Vul een geldige postcode in'
    },
    tboxL15HouseNumber: {
        required: 'Vul een geldig huisnummer in',
        regex: 'Vul een geldig huisnummer in'
    },
    tboxL15HouseNumberAddition: {
        regex: 'Vul een geldige toevoeging in'
    },
    tboxL15PhoneNumber: {
        required: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -',
        regex: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -'
    },

	// L11
    txtL11lightboxZipCode: {
        required: 'Vul een geldige postcode in',
        regex: 'Vul een geldige postcode in'
    },
    txtL11lightboxHouseNumber: {
        required: 'Vul een geldig huisnummer in',
        regex: 'Vul een geldig huisnummer in'
    },
    txtL11lightboxHouseNumberAddition: {
        regex: 'Vul een geldige toevoeging in'
    },
	
    // L18
    tboxPostCode: {
        required: 'Vul een geldige postcode in',
        regex: 'Vul een geldige postcode in'
    },
    tboxHouseNumber: {
        required: 'Vul een geldig huisnummer in',
        regex: 'Vul een geldig huisnummer in'
    },
    tboxHouseNumberAddition: {
        regex: 'Vul een geldige toevoeging in'
    },

    // L26
    txtL23L26StreetZip: {
        required: 'Vul de woonplaats of postcode in',
        notregex: 'Vul een geldige postcode in'
    },
    txtL23L26HouseNumber: {
        required: 'Vul een geldig huisnummer in',
        regex: 'Vul een geldig huisnummer in'
    },
    txtL23L26NumberAddition: {
        regex: 'Vul een geldige toevoeging in'
    },
    txtL23L26Place: {
        required: 'Vul de woonplaats in'
    },
    
    //L26_widget
    txtL26WidgetStreetZip: {
        required: 'Vul de woonplaats of postcode in',
        notregex: 'Vul een geldige postcode in'
    },
    txtL26WidgetHouseNumber: {
        required: 'Vul een geldig huisnummer in',
        regex: 'Vul een geldig huisnummer in'
    },
    txtL26WidgetPlace: {
        required: 'Vul de woonplaats in'
    },
	
    // C2
    tboxC2ZipCode: {
        regex: 'Vul een geldige postcode in'
    },
    tboxC2HouseNumber: {
        regex: 'Vul een geldig huisnummer in'
    },
    // C2.1
    tboxC2_1ZipCode: {
        regex: 'Vul een geldige postcode in'
    },
    tboxC2_1HouseNumber: {
        regex: 'Vul een geldig huisnummer in'
    },
    tboxC2_1AskingPrice: {
        regex: 'Alleen hele getallen zijn toegestaan'
    },
    // C2.2
    tboxC2_2ZipCode: {
        regex: 'Vul een geldige postcode in'
    },
    tboxC2_2HouseNumber: {
        regex: 'Vul een geldig huisnummer in'
    },
    tboxC2_2AskingPrice: {
        regex: 'Alleen hele getallen zijn toegestaan'
    },
    tboxC2_2DesiredPrice: {
        regex: 'Alleen hele getallen zijn toegestaan'
    },
    // C3
    tboxC3FirstName: {
        required: 'Vul uw voornaam in'
    },
    tboxC3LastName: {
        required: 'Vul uw achternaam in'
    },
    C3Gender: {
        required: 'Geef aan of u man of vrouw bent.'
    },
    tboxC3EmailAddress: {
        required: 'Vul uw email adres in',
        email: 'Vul een geldig email adres in',
        remote: 'Dit email adres staat reeds geregistreerd, vul een ander email adres in'
    },
    tboxC3PhoneNumber: {
        required: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -',
        regex: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -'
    },

    // C4
    tboxC4Password: {
        required: 'Vul een wachtwoord van minimaal 6 karakters in bestaande uit minimaal 2 cijfers en minimaal 2 letters',
        regex: 'Vul een wachtwoord van minimaal 6 karakters in bestaande uit minimaal 2 cijfers en minimaal 2 letters'
    },
    tboxC4RetypePassword: {
        equalTo: 'Het wachtwoord is niet gelijk'
    },

    // C5
    C5SendBy: {
        required: 'Selecteer hoe u de informatie wilt ontvangen'
    },
    tboxC5ZipCode1: {
        required: 'Vul een geldige postcode in',
        regex: 'Vul een geldige postcode in'
    },
    tboxC5HouseNumber1: {
        required: 'Vul een geldig huisnummer in',
        regex: 'Vul een geldig huisnummer in'
    },
    tboxC5ZipCode2: {
        required: 'Vul een geldige postcode in',
        regex: 'Vul een geldige postcode in'
    },
    tboxC5HouseNumber2: {
        required: 'Vul een geldig huisnummer in',
        regex: 'Vul een geldig huisnummer in'
    },
    ddlC5AppointmentOffice: {
        required: 'Selecteer een kantoor in uw regio'
    },

    // C7
    tboxC7EmailAddress: {
        required: 'Vul uw email adres in',
        email: 'Vul een geldig email adres in',
        remote: 'Dit email adres staat reeds geregistreerd, vul een ander email adres in'
    },

    // L73
    tboxL73EmailAddress: {
        required: 'Vul uw email adres in',
        email: 'Vul een geldig email adres in',
        remote: ''
    },

	tboxL73DOB_Year: {
		required: 'vul uw geboortedatum in'
	},
	
    // C19
    tboxC19FirstName: {
        required: 'Vul uw voorletter(s) in'
    },
    tboxC19LastName: {
        required: 'Vul uw achternaam in'
    },
    C19Gender: {
        required: 'Geef aan of u man of vrouw bent'
    },
	tboxC19DOB_Year: {
		requred: 'Selecteer een datum'
	},
    tboxC19Email: {
        required: 'Vul uw email adres in',
        email: 'Vul een geldig email adres in',
        remote: 'Dit email adres staat reeds geregistreerd,vul een ander email adres in'
    },
    tboxC19PhoneNumber1: {
        required: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -',
        regex: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -'
    },
    tboxC19PhoneNumber2: {
        regex: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -'
    },
    // C20
    tboxC20PartnerFirstName: {
        required: 'Vul uw voorletter(s) in'
    },
    tboxC20PartnerLastName: {
        required: 'Vul uw achternaam in'
    },
    C20Gender: {
        required: 'Geef aan of u man of vrouw bent'
    },
    tboxC20PartnerEmail: {
        email: 'Vul een geldig email adres in',
        remote: 'Dit email adres staat reeds geregistreerd, vul een ander email adres in'
    },
    tboxC20PartnerPhoneNumber1: {
        regex: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -'
    },
    tboxC20PartnerPhoneNumber2: {
        regex: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -'
    },
    tboxC20PartnerCurrentAddressZipCode: {
        regex: 'Vul een geldige postcode in'
    },

    // C21
    tboxC21CurrentPassword: {
        required: 'Vul uw huidige wachtwoord in',
        remote: 'Wachtwoord is onjuist'
    },
    tboxC21NewPassword: {
        required: 'Vul een wachtwoord van minimaal 6 karakters in bestaande uit minimaal 2 cijfers en minimaal 2 letters',
        regex: 'Vul een wachtwoord van minimaal 6 karakters in bestaande uit minimaal 2 cijfers en minimaal 2 letters'
    },
    tboxC21RetypeNewPassword: {
        equalTo: 'Het wachtwoord is niet gelijk'
    },

    // C22
    C22StartPage: {
        required: 'Geef aan welke startpagina u wenst'
    },

    // L62
    tboxL62LoginUsername: {
        required: 'De inlognaam is niet bekend',
		remote: ''
    },
    tboxL62LoginPassword: {
        required: 'Vul een wachtwoord in',
		remote: ''
    },
    tboxL62SignUpEmailAddress: {
        required: 'Vul uw email adres in',
        email: 'Vul een geldig email adres in',
        remote: 'Dit email adres staat reeds geregistreerd, vul een ander email adres in'
    },
    tboxL62SignUpPassword: {
        required: 'Vul een wachtwoord van minimaal 6 karakters in bestaande uit minimaal 2 cijfers en minimaal 2 letters',
        regex: 'Vul een wachtwoord van minimaal 6 karakters in bestaande uit minimaal 2 cijfers en minimaal 2 letters'
    },
    tboxL62SignUpRetypePassword: {
        equalTo: 'Het wachtwoord is niet gelijk'
    },

    // L2
    tboxL2LoginName: {
        required: 'De inlognaam is niet bekend',
        remote: ''
    },
    tboxL2Password: {
        required: 'Vul uw wachtwoord in',
        remote: ''
    },

    // L68
    tboxL68PhoneNumber: {
        required: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -',
        regex: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -'
    },

    // L74
    tboxL74Password: {
        required: 'Vul een wachtwoord van minimaal 6 karakters in bestaande uit minimaal 2 cijfers en minimaal 2 letters',
        regex: 'Vul een wachtwoord van minimaal 6 karakters in bestaande uit minimaal 2 cijfers en minimaal 2 letters'
    },
    tboxL74RetypePassword: {
        equalTo: 'Het wachtwoord is niet gelijk'
    },

    // A39
    tboxA39ZipCode: {
        required: 'Vul een geldige postcode in',
        regex: 'Vul een geldige postcode in'
    },
    tboxA39HouseNumber: {
        required: 'Vul een geldig huisnummer in',
        regex: 'Vul een geldig huisnummer in'
    },
    tboxA39PhoneNumber: {
        required: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -',
        regex: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -'
    },

    // V1
    tboxV1ZipCode: {
        required: 'Vul een geldige postcode in',
        regex: 'Vul een geldige postcode in'
    },
    tboxV1HouseNumber: {
        required: 'Vul een geldig huisnummer in',
        regex: 'Vul een geldig huisnummer in'
    },
	
	ddlV24AppointmentTilMinute: {
		validTime: 'Kies een eindtijd die na de starttijd ligt'
	},
	
	ddlV23V25AppointmentTilMinute: {
		validTime: 'Kies een eindtijd die na de starttijd ligt'
	},
	
	ddlV26_1AppointmentTilMinute: {
		validTime: 'Kies een eindtijd die na de starttijd ligt'
	},

	// P54
	tboxP54ZipCode: {
	    required: 'Vul een geldige postcode in',
	    regex: 'Vul een geldige postcode in'
	},
	tboxP54HouseNumber: {
	    required: 'Vul een geldig huisnummer in',
	    regex: 'Vul een geldig huisnummer in'
	},
	txtP54Street: {
		required: 'street name'
	},
	txtP54City: {
		required: 'city name'
	},	
	
    // M52
    tboxM52LoginEmail: {
        required: 'De inlognaam is niet bekend',
		remote: ''
    },
    tboxM52LoginEmailPassword: {
        required: '',
		remote:''
    },
    tboxM52RegisterEmail: {
        required: 'Vul uw email adres in',
        email: 'Vul een geldig email adres in',
        remote: 'Dit email adres staat reeds geregistreerd, vul een ander email adres in'
    },
    tboxM52RegisterPassword: {
        required: 'Vul een wachtwoord van minimaal 6 karakters in bestaande uit minimaal 2 cijfers en minimaal 2 letters',
        regex: 'Vul een wachtwoord van minimaal 6 karakters in bestaande uit minimaal 2 cijfers en minimaal 2 letters'
    },
    tboxM52RegisterConfirmPassword: {
        equalTo: 'Het wachtwoord is niet gelijk'
    },
	chkM52GeneralConditions: {
		required: 'U dient akkoord te gaan met de algemene voorwaarden'
	},
	
	//M46
	tboxM46EmailAddress1: {
		required: 'Vul uw email adres in',
		email: 'Vul een geldig email adres in'
	},
	
	tboxM46EmailAddress2: {
		required: 'Vul uw email adres in',
		email: 'Vul een geldig email adres in'
	},

	//M38.1
	tboxM38_1EmailAddress1: {
	    required: 'Vul uw email adres in',
	    email: 'Vul een geldig email adres in'
	},

	tboxM38_1EmailAddress2: {
	    required: 'Vul uw email adres in',
	    email: 'Vul een geldig email adres in'
	},
	
	// A50
	tboxNameTogether: {
		required: 'Vul uw naam in'
	},
	tboxEmailTogether: {
		required: 'Vul uw email adres in',
	    email: 'Vul een geldig email adres in'
	},
	tboxPhoneNoTogether: {
		required: 'Vul een geldig telefoonnummer in',
		regex: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -'
	},
	tboxOfferStep2: {
		required: 'Vul uw bod in'
	},
	tboxNameStep2: {
		required: 'Vul uw naam in'
	},
	tboxEmailStep2: {
		required: 'Vul uw email adres in',
	    email: 'Vul een geldig email adres in'
	},
	tboxPhoneNoStep2: {
		required: 'Vul een geldig telefoonnummer in',
		regex: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -'
	},
	tboxMyBidToDate: {
		required: 'Selecteer een datum tot wanneer uw bod geldig is'
	},
	tboxTransferDate: {
	required: 'Selecteer een datum voor overdracht'
	},
	
	//A44.2
    tboxType1235Date: {
        required: 'Vul een datum in'        
    },    
    tboxType125Name: {
        required: 'Vul uw naam in'
    },
    tboxType125Email: {
		required: 'Vul uw email adres in',
	    email: 'Vul een geldig email adres in'
    },
    tboxType125Telephone: {
		required: 'Vul een geldig telefoonnummer in',
		regex: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -'
    },	
	
	
	//A44.3
	tboxA44_3_ShipToZipcode: {
	    required: 'Vul een geldige postcode in',
	    regex: 'Vul een geldige postcode in'
	},
	tboxA44_3_ShipToHouseNr: {
	    required: 'Vul een geldig huisnummer in',
	    regex: 'Vul een geldig huisnummer in'
	},
	tboxA44_3_ShipToCity: {
		required: 'Vul een gemeente of woonplaats in'
	},
	
	//M51
    tboxM51Email: {
        required: 'Vul uw email adres in',
        email: 'Vul een geldig email adres in',
        remote: 'Dit email adres staat reeds geregistreerd, vul een ander email adres in'
    },
    tboxM51Password: {
        required: 'Vul een wachtwoord van minimaal 6 karakters in bestaande uit minimaal 2 cijfers en minimaal 2 letters',
        regex: 'Vul een wachtwoord van minimaal 6 karakters in bestaande uit minimaal 2 cijfers en minimaal 2 letters'
    },
    tboxM51RetypePassword: {
        equalTo: 'Het wachtwoord is niet gelijk'
    },
	
	// N43
	tboxN43YourName: {
		required: 'Vul uw naam in'
	},
	tboxN43EmailAddress: {
		required: 'Vul uw email adres in',
        email: 'Vul een geldig email adres in'
	},
	tboxN43AreaQuestion: {
		required: 'Stel een vraag'
	},
	tboxN43PhoneNumber: {
		required: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -',
		regex: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -'
	},

    //N9
    txtN9AccountName: {
        required: 'Vul naam rekeninghouder in'
    },
    txtN9AccountNumber: {
        required: 'Vul rekeningnummer in',
        validAccountNumber: 'Ongeldig rekeningnummer'
    },
    txtN9City: {
        required: 'Vul plaatsnaam in'
    },
	
	// N17
    txtN17Name: {
        required: 'Vul uw naam in'
    },
    txtN17Email: {
		required: 'Vul uw email adres in',
        email: 'Vul een geldig email adres in'
    },
	txtN17Question: {
		required: 'Stel een vraag'
	},
	txtN17Phone: {
		required: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -',
		regex: 'Vul een geldig telefoonnummer in. Toegestane karakters zijn getallen 0 t/m 9 ( ) + -'
	}	
};

/* 
* Custom validation methods.
*/
$(document).ready(function() {

    $.validator.addMethod(
		'regex',
		function(value, element, regexp) {
		    var re = new RegExp(regexp);
		    return this.optional(element) || re.test(value);
		},
		'Check input'
	);

	$.validator.addMethod(
		'notregex',
		function(value, element, regexp) {
		    var re = new RegExp(regexp);
		    return this.optional(element) || !re.test(value);
		},
		'Check input'
	);

    $.validator.addMethod(
		'validAccountNumber',
		function(value, element) {
		    var sum = 0;
		    var account = $(element).val();
		    var length = account.length;
		    var isValid = false;
		    
		    if (length == 9 || length == 10) {
		        for (i = 1; i < (length + 1); i++) {
		            number = account.charAt(i - 1);
		            sum += (length == 10) ? (number * i) : (number * (10 - i));
		        }
		        isValid = (sum % 11 == 0);
		    } else if ( length < 9 ) {
				isValid = true;
			}
			
		    return this.optional(element) || isValid;
		},
		'Check input'
	);

    // param is {day:'day element selector', month:'month element selector', year:'year element selector'}
    $.validator.addMethod(
		'validDate',
		function(value, element, param) {
		    var selectors = param;

		    if (!(this.triggered === true)) {
		        $(element).data('elementVisited', true);
		    }

		    var dayField = $(selectors.day, $(element).parents('.logical-form'));
		    var monthField = $(selectors.month, $(element).parents('.logical-form'));
		    var yearField = $(selectors.year, $(element).parents('.logical-form'));

		    var required = true;
		    if (selectors.required) {
		        if ($(selectors.required, $(element).parents('.logical-form')).size() > 0) {
		            required = true;
		        } else {
		            required = false;
		        }
		    }
		    if (!required) return true;

		    var day, month, year;

		    day = parseInt(dayField.val(), 10);
		    month = parseInt(monthField.val(), 10);
		    year = parseInt(yearField.val(), 10);

		    if (dayField.data('elementVisited') === true || this.checkAll) {
		        if (dayField.val() == '') {
		            this.settings.messages[$.getAspElementName(element)] = 'Vul een geldige dag in';
		            return false; //this.optional(element) || false;
		        }

		        if (isNaN(day) || day < 1 || day > 31) {
		            this.settings.messages[$.getAspElementName(element)] = 'Vul een geldige dag in';
		            return false; //this.optional(element) || false;
		        }
		    }

		    if (monthField.data('elementVisited') === true || this.checkAll) {
		        if (isNaN(month) || month < 1 || month > 12) {
		            this.settings.messages[$.getAspElementName(element)] = 'Selecteer een maand';
		            return false; //this.optional(element) || false;
		        }
		    }

		    if (yearField.data('elementVisited') === true || this.checkAll) {
		        if (yearField.val() == '') {
		            this.settings.messages[$.getAspElementName(element)] = 'Vul een geldig jaar in';
		            return false; //this.optional(element) || false;
		        }


		        if (isNaN(year) || year < 1900 || year > (new Date()).getFullYear()) {
		            this.settings.messages[$.getAspElementName(element)] = 'Vul een geldig jaar in';
		            return false; //this.optional(element) || false;
		        }
		    }

		    if (this.checkAll ||
					(yearField.data('elementVisited') === true && monthField.data('elementVisited') === true && dayField.data('elementVisited') === true)) {

		        var daysInFebruary = function(year) {
		            return (((year % 4 == 0) && ((!(year % 100 == 0)) || (year % 400 == 0))) ? 29 : 28);
		        };

		        var daysInMonth = function(i) {
		            var days = 31;
		            if (i == 4 || i == 6 || i == 9 || i == 11) { days = 30 }
		            if (i == 2) { days = 29 }
		            return days;
		        };

		        if (isNaN(day) || isNaN(month) || isNaN(year) || day < 1 || month > 12 || day > daysInMonth(month) ||
						year < 1900 || year > (new Date()).getFullYear() ||
						(month == 2 && day > daysInFebruary(year))) {
		            this.settings.messages[$.getAspElementName(element)] = 'Vul een geldig datum in';
		            return false; //this.optional(element) || false;
		        }
		    }

		    return true; //this.optional(element) || true;
		}
	);

    // param - jQuery selector of an elements that should be validated
    $.validator.addMethod(
		'trigger',
		function(value, element, param) {
		    var selector = param;

		    $(element).data('elementVisited', true);
		    var target = $(selector, $(element).parents('.logical-form')).get(0);
		    if (!this.checkAll && target != element) {
		        this.triggered = true;
		        this.element(target);
		        this.triggered = false;
		    }

		    return true;
		},
		''
	);

    $.validator.addMethod(
		'validTime',
		function(value, element, param) {

		    if (!(this.triggered === true)) {
		        $(element).data('elementVisited', true);
		    }

		    var fromHour = $(param.fromHour, $(element).parents('.logical-form'));
		    var fromMinute = $(param.fromMinute, $(element).parents('.logical-form'));
		    var tilHour = $(param.tilHour, $(element).parents('.logical-form'));
		    var tilMinute = $(param.tilMinute, $(element).parents('.logical-form'));

		    if (this.checkAll || (tilHour.data('elementVisited') === true && tilMinute.data('elementVisited') === true)) {
		        var fromTime = parseInt(fromHour.val()) * 60 + parseInt(fromMinute.val());
		        var tilTime = parseInt(tilHour.val()) * 60 + parseInt(tilMinute.val());
		        if (tilTime < fromTime) {
		            return false;
		        }
		    }

		    return true;
		},
		''
	);

    $.validator.addMethod(
		'validP54address',
		function(value, element, param) {

		    if (!(this.triggered === true)) {
		        $(element).data('elementVisited', true);
		    }

		    var postCode = $(param.postCode, $(element).parents('.logical-form'));
		    var houseNumber = $(param.houseNumber, $(element).parents('.logical-form'));
		    var manualAddress = $(param.manualAddress, $(element).parents('.logical-form'));
		    var street = $(param.street, $(element).parents('.logical-form'));
		    var city = $(param.city, $(element).parents('.logical-form'));
		    var streetLabel = $(param.streetLabel, $(element).parents('.logical-form'));
		    var cityLabel = $(param.cityLabel, $(element).parents('.logical-form'));

		    if (postCode.data('elementVisited') && houseNumber.data('elementVisited') &&
					!manualAddress[0].checked) {
		        var resp;
		        $.ajax({
		            async: false,
		            cahche: false,
		            type: 'POST',
		            url: '/_vti_bin/PortalValidationService.asmx/GetAddressByPostalCode',
		            data: JSON.stringify({
		                zipCode: postCode.val(),
		                houseNumber: houseNumber.val()
		            }),
		            dataFilter: function(data, type) {
		                data = JSON.parse(data);
		                resp = data.d;
		                return data.d;
		            },
		            contentType: "application/json; charset=utf-8",
		            dataType: 'json'
		        });
		        street.val(resp[0]);
		        streetLabel.html(resp[0]);
		        city.val(resp[1]);
		        cityLabel.html(resp[1]);

		        if (resp[0] == "" && resp[1] == "") {
		            this.settings.messages[$.getAspElementName(element)] = 'Vul een geldige postcode/huisnummer in';
		            return false;
		        }

		        return true;
		    }

		    return true;
		},
		''
	);

});