PageSourceSearch

https://origin-cdnh.policyboss.com/website/UI22/js/validate_init.js

js policyboss.com collected 2026-10-08 01:58:04 UTC 19,062 bytes, 621 lines download raw bytes

1$(function() {
2    jQuery.validator.setDefaults({
3        highlight: function(element) {
4            if ($(element).closest('.js-input-group').length) {
5                $(element).closest('.js-input-group').addClass('has-error');
6            } else {
7                $(element).parent().addClass('has-error');
8            }
9        },
10        unhighlight: function(element) {
11            if ($(element).closest('.js-input-group').length) {
12                $(element).closest('.js-input-group').removeClass('has-error');
13            } else {
14                $(element).parent().removeClass('has-error');
15            }
16        },
17        errorElement: 'span',
18        errorClass: 'help-block',
19        errorPlacement: function(error, element) {
20            if (element.closest('.js-input-group').length) {
21                if (element.closest('.js-input-group').parent().find('.help-block').length) {
22                    element.closest('.js-input-group').parent().find('.help-block').remove();
23                }
24                error.insertAfter(element.closest('.js-input-group'));
25            } else {
26                if (element.parent('.has-error').find('.help-block').length) {
27                    element.parent('.has-error').find('.help-block').remove();
28                }
29                error.insertAfter(element);
30            }
31        },
32        onfocusout: false
33    });
34
35    $.validator.addMethod('validatePostelcode', function(value, element) {
36        var patt = /\b((?:(?:gir)|(?:[a-pr-uwyz])(?:(?:[0-9](?:[a-hjkpstuw]|[0-9])?)|(?:[a-hk-y][0-9](?:[0-9]|[abehmnprv-y])?)))) ?([0-9][abd-hjlnp-uw-z]{2})\b/i;
37
38        return res = patt.test(value);
39    }, 'Invalid postel code.');
40
41    function scrollOnError(validator) {
42        $('html, body').animate({
43            scrollTop: $(validator.errorList[0].element).offset().top 
44        }, 'fast', function() {
45            validator.errorList[0].element.focus();
46        });
47    };
48
49
50    jQuery.validator.addMethod("email", function(value, element) {
51        return this.optional(element) || (/^[a-z0-9]+([-._][a-z0-9]+)*@([a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,4}$/.test(value) && /^(?=.{1,64}@.{4,64}$)(?=.{6,100}$).*/.test(value));
52    }, 'Invalid email address');
53
54    $.validator.addMethod('filesize', function(value, element, param) {
55        // param = size (en bytes)
56        // element = element to validate (<input>)
57        // value = value of the element (file name)
58        return this.optional(element) || (element.files[0].size <= param)
59    });
60
61    $.validator.addMethod('phoneUK', function(phone_number, element) {
62        return this.optional(element) || phone_number.length > 9 &&
63            phone_number.match(/^(\+44\s?7\d{3}|\(?07\d{3}\)?)\s?\d{3}\s?\d{3}$/);
64    }, 'Please specify a valid phone number');
65
66    $.validator.addMethod("alpha", function(value, element) {
67        return this.optional(element) || value == value.match(/^[a-zA-Z][a-zA-Z\s-]*$/);
68    }, 'Only alphabets are allowed.');
69    
70    $.validator.addMethod("reasonSpace", function(value, element) {
71        return this.optional(element) || value == value.match(/^[^-\s][a-zA-Z0-9_\s-]+$/);
72    }, 'Please Enter Valid Reason.');
73
74    $.validator.addMethod("allowNumericWithDecimal", function(value, element) {
75        return this.optional(element) || value == value.match(/^\+?[0-9]*\.?[0-9]+$/);
76    }, 'Please Enter only digits.');
77
78    $.validator.addMethod("regex", function(value, element, regexp) {
79          var re = new RegExp(regexp);
80          return this.optional(element) || re.test(value);
81        },"Please check your input.");
82
83    $.validator.addMethod("audioTracksValidation", function(value, element, regexp) {
84            var re = new RegExp(regexp);
85            return this.optional(element) || re.test(value);
86        },"Audio track must be a file of type: mp3, ogg, wav.");
87  
88    jQuery.validator.addClassRules("js-audio-tracks",{
89        audioTracksValidation: /\.(?:wav|mp3|ogg)$/,
90    });
91
92    $.validator.addMethod("photosValidation", function(value, element, regexp) {
93        var re = new RegExp(regexp);
94        return this.optional(element) || re.test(value);
95    },"Image must be a file of type: jpeg, png, gif, jpg.");
96
97    jQuery.validator.addClassRules("js-photos",{
98        photosValidation: /\.(?:jpeg|png|gif|jpg)$/,
99    });
100
101    jQuery.validator.addClassRules("js-audio-tracks-required",{
102        audioTrackRequired: true,
103    });
104
105    $.validator.addMethod("audioTrackRequired", $.validator.methods.required,
106    "Audio track is required.");
107
108    jQuery.validator.addClassRules("js-photo-required",{
109        photoRequired: true,
110    });
111
112    $.validator.addMethod("characterNameRequired", $.validator.methods.required,
113    "Name is required.");
114
115    jQuery.validator.addClassRules("js-character-name-required",{
116        characterNameRequired: true,
117    });
118
119    $.validator.addMethod("photoRequired", $.validator.methods.required,
120    "Image is required.");
121
122    jQuery.validator.addMethod("noSpace", function(value, element) { 
123    return value == '' || value.trim().length != 0;  
124    }, "Answer is required.");
125
126    $("#contact-us-form").validate({
127        rules: {
128            name: {
129                required: true,
130                alpha: true
131            },
132            mobile: {
133                required: true,
134                number: true,
135            },
136            city: {
137                required: true,
138            },
139            select: {
140                required: true
141            }
142        },
143        messages: {
144            name: {
145                required: "Name is required.",
146            },
147            mobile: {
148                required: "Mobile Number is required.",
149                number: "Only numbers are allowed."
150            },
151            city: {
152                required: "City is required.",
153            },
154            select: {
155                required: "This is required.",
156            }
157        },
158        invalidHandler: function(form, validator) {
159            // if (!validator.numberOfInvalids())
160                scrollOnError(validator);
161        }
162    });
163    $("#home-banner-form").validate({
164        rules: {
165            number: {
166                required: true,
167                number: true,
168                min: 10,
169            }
170        },
171        messages: {
172            number: {
173                required: "Mobile Number is required.",
174                min: "Please enter at least 10 digits."
175            }
176        },
177        invalidHandler: function(form, validator) {
178            // if (!validator.numberOfInvalids())
179                // scrollOnError(validator);
180        }
181    });
182    $("#landing-banner-form").validate({
183        rules: {
184            number: {
185                required: true,
186                number: true,
187                min: 10,
188            }
189        },
190        messages: {
191            number: {
192                required: "Mobile Number is required.",
193                min: "Please enter at least 10 digits."
194            }
195        },
196        invalidHandler: function(form, validator) {
197            // if (!validator.numberOfInvalids())
198                // scrollOnError(validator);
199        }
200    });
201    $('#view-quote-form').validate({
202        rules: {
203            registration_no : {
204                required: true,
205            },
206            member_age_input : {
207                required: true,
208            },
209            pincode_number_field : {
210                required: true,
211            }
212        },
213        messages: {
214            registration_no: {
215                required: "Car number is required.",
216            },
217            member_age_input : {
218                required: "Member Age is required.",
219            },
220            pincode_number_field : {
221                required: "Pincode is required.",
222            }
223        },
224        invalidHandler: function(form, validator) {
225            // if (!validator.numberOfInvalids())
226                // scrollOnError(validator);
227        }
228    });
229    $("#connect-us-form").validate({
230        rules: {
231            mobile_number: {
232                required: true,
233                number: true,
234            },
235            select: {
236                required: true
237            },
238            date: {
239                required: true
240            },
241            time: {
242                required: true
243            }
244        },
245        messages: {
246            mobile_number: {
247                required: "Mobile Number is required.",
248                number: "Only numbers are allowed."
249            },
250            select: {
251                required: "This is required.",
252            },
253            date: {
254                required: "Date is required"
255            },
256            time: {
257                required: "Time is required"
258            }
259        },
260        invalidHandler: function(form, validator) {
261            // if (!validator.numberOfInvalids())
262                scrollOnError(validator);
263        }
264    });
265    $("#explore-form").validate({
266        rules: {
267            number: {
268                required: true,
269                number: true,
270            }
271        },
272        messages: {
273            number: {
274                required: "Mobile Number is required.",
275            }
276        },
277        invalidHandler: function(form, validator) {
278            // if (!validator.numberOfInvalids())
279                scrollOnError(validator);
280        }
281    });
282    $("#explore-find-form").validate({
283        rules: {
284            number: {
285                required: true,
286                number: true,
287            }
288        },
289        messages: {
290            number: {
291                required: "Mobile Number is required.",
292            }
293        },
294        invalidHandler: function(form, validator) {
295            // if (!validator.numberOfInvalids())
296                scrollOnError(validator);
297        }
298    });
299    $("#join-now-form").validate({
300        rules: {
301            name: {
302                required: true,
303            },
304            email: {
305                required: true
306            },
307            mobile: {
308                required: true,
309                number: true,
310            },
311            city: {
312                required: true,
313            }
314        },
315        messages: {
316            name: {
317                required: "Name is required.",
318            },
319            email: {
320                required: "Email is required.",
321            },
322            mobile: {
323                required: "Mobile Number is required.",
324                number: "Only numbers are allowed."
325            },
326            city: {
327                required: "City is required.",
328            }
329        },
330        invalidHandler: function(form, validator) {
331            // if (!validator.numberOfInvalids())
332                scrollOnError(validator);
333        }
334    });
335    $("#modal-join-now-form").validate({
336        rules: {
337            name_field: {
338                required: true,
339            },
340            email_field: {
341                required: true
342            },
343            mobile_field: {
344                required: true,
345                number: true,
346            },
347            city_field: {
348                required: true,
349            }
350        },
351        messages: {
352            name_field: {
353                required: "Name is required.",
354            },
355            email_field: {
356                required: "Email is required.",
357            },
358            mobile_field: {
359                required: "Mobile Number is required.",
360                number: "Only numbers are allowed."
361            },
362            city_field: {
363                required: "City is required.",
364            }
365        },
366        invalidHandler: function(form, validator) {
367            // if (!validator.numberOfInvalids())
368                scrollOnError(validator);
369        }
370    });
371    $("#basic_detil_form").validate({
372        rules: {
373            registration_no: {
374                required: true,
375                // regex : /^[A-Za-z]{2,3}(-\d{2}(-[A-Za-z]{1,2})?)?-\d{3,4}$/
376            },
377            owner_name: {
378                required: true,
379                alpha: true
380            },
381            email_add: {
382                required: true
383            },
384            mobile_num: {
385                required: true,
386                number: true,
387                regex : /^(\+\d{1,3}[- ]?)?\d{10}$/
388            },
389        },
390        messages: {
391            registration_no:{
392                required: "Please enter Registration Number",
393                regex : "Invalid Number"
394            },
395            owner_name: {
396                required: "Please enter Owner Name",
397                alpha: "Invalid input."
398            },
399            email_add: {
400                required: "Email is required.",
401            },
402            mobile_num: {
403                required: "Mobile Number is required.",
404                number: "Only numbers are allowed.",
405                max: "Please enter maximum 10 digits.",
406                regex : "Please Enter Valid Number."
407            },
408        },
409        invalidHandler: function(form, validator) {
410            if (!validator.numberOfInvalids())
411                scrollOnError(validator);
412        }
413    });
414    $("#personal_detil_form").validate({
415        rules: {
416            nominee_name: {
417                required: true,
418                alpha: true
419            },
420            age: {
421                required: true,
422            },
423            relation: {
424                required: true,
425            }
426        },
427        messages: {
428            nominee_name: {
429                required: "Please enter Nominee Name",
430                alpha: "Invalid input."
431            },
432            age: {
433                required: "Please Select Age",
434            },
435            relation: {
436                required: "Please Select Relation",
437            }
438        },
439        invalidHandler: function(form, validator) {
440            if (!validator.numberOfInvalids())
441                scrollOnError(validator);
442        }
443    });
444    $("#address_form").validate({
445        rules: {
446            address_input: {
447                required: true
448            },
449            pincode_input: {
450                required: true,
451                number: true,
452                regex: /^[1-9][0-9]{5}$/
453            },
454            previous_policy_number: {
455                required: true
456            }
457        },
458        messages: {
459            address_input: {
460                required: "Please enter Registred Address"
461            },
462            pincode_input: {
463                required: "Please enter Pincode",
464                number: "Invalid input.",
465                regex: "Please Enter Valid Pincode."
466            },
467            previous_policy_number: {
468                required: "Please enter Previous Policy Number"
469            }
470        },
471        invalidHandler: function(form, validator) {
472            if (!validator.numberOfInvalids())
473                scrollOnError(validator);
474        }
475    });
476    $("#car_detil_form").validate({
477        rules: {
478            engine_number: {
479                required: true
480            },
481            chassis_number: {
482                required: true
483            },
484            loan_provider : {
485                required: true
486            }
487        },
488        messages: {
489            engine_number: {
490                required: "Please enter Engine Number"
491            },
492            chassis_number: {
493                required: "Please enter Chassis Number"
494            },
495            loan_provider : {
496                required: "Please Select Loan Provider"
497            }
498        },
499        invalidHandler: function(form, validator) {
500            if (!validator.numberOfInvalids())
501                scrollOnError(validator);
502        }
503    });
504    $("#send_email_form").validate({
505        rules: {
506            send_email:{
507                required: true,
508                email: true
509            }
510        },
511        messages: {
512            send_email:{
513                required:"Email is required",
514                email: "Please enter valid email"
515            }
516        },
517        invalidHandler: function(form, validator) {
518            if (!validator.numberOfInvalids())
519                scrollOnError(validator);
520        }
521    });
522
523    $("#proposer_detil_form").validate({
524        rules: {
525            name: {
526                required: true,
527            },
528            email_add: {
529                required: true
530            },
531            mobile_num: {
532                required: true,
533                number: true,
534                regex : /^(\+\d{1,3}[- ]?)?\d{10}$/
535            },
536            pincode_input: {
537                required: true,
538                number: true,
539                regex: /^[1-9][0-9]{5}$/
540            },
541            address: {
542                required: true,
543            },
544            state: {
545                required: true,
546            },
547            nominee_name: {
548                required: true,
549                alpha: true
550            }
551        },
552        messages: {
553            address: {
554                required: "Please enter Address"
555            },
556            pincode_input: {
557                required: "Please enter Pincode",
558                number: "Invalid input.",
559                regex: "Please Enter Valid Pincode."
560            },
561            email_add: {
562                required: "Email is required.",
563            },
564            mobile_num: {
565                required: "Mobile Number is required.",
566                number: "Only numbers are allowed.",
567                max: "Please enter maximum 10 digits.",
568                regex : "Please Enter Valid Number."
569            },
570            state: {
571                required: "Please enter State"
572            },
573            nominee_name: {
574                required: "Please enter Nominee Name",
575                alpha: "Invalid input."
576            }
577        },
578        invalidHandler: function(form, validator) {
579            if (!validator.numberOfInvalids())
580                scrollOnError(validator);
581        }
582    });
583    $("#insured_detil_form").validate({
584        rules: {
585            adult_name: {
586                required: true,
587            },
588            child_name: {
589                required: true,
590            },
591            adult_weight: {
592                required: true,
593                number: true,
594            },
595            child_weight: {
596                required: true,
597                number: true,
598            },
599        },
600        messages: {
601            adult_name: {
602                required: "Please enter Nominee Name",
603            },
604            adult_weight: {
605                required: "Please enter Weight",
606                number: "Weight should be in valid format."
607            },
608            child_name: {
609                required: "Please enter Nominee Name",
610            },
611            child_weight: {
612                required: "Please enter Weight",
613                number: "Weight should be in valid format."
614            },
615        },
616        invalidHandler: function(form, validator) {
617            if (!validator.numberOfInvalids())
618                scrollOnError(validator);
619        }
620    });
621});

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.