PageSourceSearch

https://demo.yo-gigs.com/public/admin.php?url=js-css/js-common&f=form-validation.js&min=0&sid=1777984253

js yo-gigs.com collected 2026-10-08 07:56:28 UTC 22,821 bytes, 521 lines download raw bytes

1/* global langLbl, datePickerFormatToDate, FCKeditorAPI, x, CKEDITOR, error, fcom */
2
3(function($) {
4    /*
5     Validation Singleton
6     */
7    var Validation = function() {
8        messages = {
9            required: "{caption} " + langLbl.isMandatory,
10            email: langLbl.pleaseEnterValidEmailId + " {caption}.",
11            charonly: langLbl.charactersSupportedFor + " {caption}.",
12            integer: langLbl.pleaseEnterIntegerValue + " {caption}.",
13            floating: langLbl.pleaseEnterNumericValue + " {caption}.",
14            username: "{caption} " + langLbl.startWithLetterOnlyAlphanumeric,
15            password: "{caption} " + langLbl.mustBeBetweenCharacters,
16            user_regex: langLbl.invalidValues + " {caption}.",
17            lengthrange: langLbl.lengthOf + " {caption} " + langLbl.mustBeBetween + " {minlength} " + langLbl.and + " {maxlength}.",
18            range: langLbl.valueOf + " {caption} " + langLbl.mustBeBetween + " {minval} " + langLbl.and + " {maxval}.",
19            selectionrange: langLbl.pleaseSelect + " {minval} " + langLbl.to + " {maxval} " + langLbl.options,
20            comparewith_lt: "{caption} " + langLbl.mustBeLessThan + " {comparefield}.",
21            comparewith_le: "{caption} " + langLbl.mustBeLessOrEqual + " {comparefield}.",
22            comparewith_gt: "{caption} " + langLbl.mustBeGreaterThan + " {comparefield}.",
23            comparewith_ge: "{caption} " + langLbl.mustBeGreaterOrEqual + " {comparefield}.",
24            comparewith_eq: "{caption} " + langLbl.mustBeSameAs + " {comparefield}.",
25            comparewith_ne: "{caption} " + langLbl.shouldNotBeSameAs + " {comparefield}."
26        };
27        parseDate = function(str, format) {
28            if (typeof(datePickerFormatToDate) == 'function') {
29                return datePickerFormatToDate(str, format);
30            } else {
31                return $.datepicker.parseDate(format, str);
32            }
33        };
34        var rules = {
35            email: {
36                check: function(rval, value) {
37                    if (rval && value)
38                        return testPattern(value, "^((?:(?:(?:[a-zA-Z0-9][\\.\\-\\+_]?)*)[a-zA-Z0-9])+)\\@((?:(?:(?:[a-zA-Z0-9][\\.\\-_]?){0,62})[a-zA-Z0-9])+)\\.([a-zA-Z0-9]{2,63})$");
39                    return true;
40                }
41            },
42            required: {
43                check: function(rval, value) {
44                    if (rval) {
45                        if (value) {
46                            return true;
47                        } else {
48                            return false;
49                        }
50                    } else {
51                        return true;
52                    }
53                }
54            },
55            charonly: {
56                check: function(rval, value) {
57                    if (rval && value) {
58                        return testPattern(value, '^[a-zA-Z\\s]*$');
59                    }
60                    return true;
61                }
62            },
63            integer: {
64                check: function(rval, value) {
65                    if (rval && value) {
66                        return testPattern(value, '^-?[\\d]+$');
67                    }
68                    return true;
69                }
70            },
71            floating: {
72                check: function(rval, value) {
73                    if (rval && value) {
74                        return testPattern(value, '^-?[\\d]*\\.?[\\d]+$');
75                    }
76                    return true;
77                }
78            },
79            username: {
80                check: function(rval, value) {
81                    if (rval && value) {
82                        return testPattern(value, '^[a-zA-Z][a-zA-Z_\\.0-9]{3,19}$');
83                    }
84                    return true;
85                }
86            },
87            password: {
88                check: function(rval, value) {
89                    if (rval && value) {
90                        return testPattern(value, '^.{6,20}$');
91                    }
92                    return true;
93                }
94            },
95            user_regex: {
96                check: function(rval, value) {
97                    if (value) {
98                        return testPattern(value, rval);
99                    }
100                    return true;
101                }
102            },
103            lengthrange: {
104                check: function(rval, value) {
105                    if (value && $.isArray(rval) && rval.length == 2) {
106                        return (value.length >= rval[0] && value.length <= rval[1]);
107                    }
108                    return true;
109                }
110            },
111            selectionrange: {
112                check: function(rval, value) {
113                    if ($.isArray(rval) && rval.length == 2) {
114                        return (value >= rval[0] && value <= rval[1]);
115                    }
116                    return true;
117                }
118            },
119            range: {
120                check: function(rval, value) {
121                    if (value) {
122                        var minval = rval.minval;
123                        var maxval = rval.maxval;
124                        if (rval.dateFormat) {
125                            minval = $.Validation.convertStringToDate(minval, rval.dateFormat).getTime();
126                            maxval = $.Validation.convertStringToDate(maxval, rval.dateFormat).getTime();
127                            value = $.Validation.convertStringToDate(value, rval.dateFormat).getTime();
128                        }
129                        if (rval.numeric) {
130                            minval = parseFloat(minval);
131                            maxval = parseFloat(maxval);
132                            value = parseFloat(value);
133                        }
134                        return (value >= minval && value <= maxval);
135                    }
136                    return true;
137                }
138            },
139            comparewith: {
140                check: function(rval, value, o) {
141                    if (o.dateFormat && rval != '' && value != '') {
142                        rval = $.Validation.convertStringToDate(rval, o.dateFormat).getTime();
143                        value = $.Validation.convertStringToDate(value, o.dateFormat).getTime();
144                    }
145                    if (o.numeric && rval != '' && value != '') {
146                        rval = parseFloat(rval);
147                        value = parseFloat(value);
148                    }
149                    switch (o.operator) {
150                        case 'lt':
151                            return (value < rval);
152                            break;
153                        case 'le':
154                            return (value <= rval);
155                            break;
156                        case 'gt':
157                            return (value > rval);
158                            break;
159                        case 'ge':
160                            return (value >= rval);
161                            break;
162                        case 'ne':
163                            return (value != rval);
164                            break;
165                        default:
166                            return (value == rval);
167                            break;
168                    }
169                }
170            }
171        }
172        var testPattern = function(value, pattern) {
173            var regExp = new RegExp(pattern, "");
174            return regExp.test(value);
175        }
176        return {
177            addRule: function(name, rule) {
178                rules[name] = rule;
179            },
180            getRule: function(name) {
181                return rules[name];
182            },
183            getMessage: function(name) {
184                return messages[name];
185            },
186            setMessages: function(obj) {
187                jQuery.extend(messages, obj);
188            },
189            convertStringToDate: function(str, format) {
190                return parseDate(str, format);
191            }
192        }
193    };
194    /*
195     Form factory
196     */
197    var Form = function(form, options) {
198        this.form = form;
199        this.options = options;
200    }
201    Form.prototype = {
202            validate: function() {
203                if (typeof FCKeditorAPI !== 'undefined') {
204                    for (x in FCKeditorAPI.Instances) {
205                        this.form.find(':hidden[name="' + x + '"]').val(FCKeditorAPI.GetInstance(x).GetXHTML(true));
206                    }
207                }
208                if (window.CKEDITOR) {
209                    for (x in CKEDITOR.instances)
210                        CKEDITOR.instances[x].updateElement();
211                }
212                if (typeof oUtil == 'object') {
213                    var editors = oUtil.arrEditor;
214                    for (x in editors) {
215                        var obj = eval(editors[x]);
216                        if ($('#' + obj.idTextArea).length) {
217                            $('#' + obj.idTextArea).val(obj.getXHTMLBody());
218                        }
219                    }
220                }
221                var $form = this;
222                $form.valid = true;
223                this.form.find("input, textarea, select").each(function() {
224                    var field = new Field(this, $form.options);
225                    field.validate();
226                    $form.valid = $form.valid && field.valid;
227                    if (0 == $form.options.errordisplay && !field.valid) {
228                        this.focus();
229                        return false;
230                    }
231                });
232            },
233            isValid: function() {
234                return this.valid;
235            }
236        }
237        /*
238         Field factory
239         */
240    var Field = function(field, options) {
241        this.settings = options;
242        this.field = $(field);
243        this.valid = false;
244        if (this.settings.errordisplay != 0 && this.settings.errordisplay != 1)
245            this.attach("change");
246        if (this.settings.errordisplay == 1 && this.settings.summaryElementId == 'validation_default') {
247            this.settings.summaryElementId = $(field).parents('form').attr('id');
248        }
249        if ($(field).attr('data-mbsunichk')) {
250            $(field).attr('autocomplete', 'off').keyup(function() {
251                $(this).attr('data-mbsunichk', '2')
252            });
253        }
254    }
255    Field.prototype = {
256            attach: function(event) {
257                var obj = this;
258                if (event == "change") {
259                    obj.field.bind("change", function() {
260                        return obj.validate();
261                    });
262                }
263                if (event == "keyup") {
264                    obj.field.bind("keyup", function(e) {
265                        return obj.validate();
266                    });
267                }
268            },
269            validate: function() {
270                var clname = 'erlist_' + this.field.attr('name').replace(/\[/g, '_').replace(/\]/g, '_');
271                if (this.field.attr('data-fat-arr-index')) {
272                    clname += '_' + this.field.attr('data-fat-arr-index');
273                }
274                $('.' + clname).remove();
275                if (this.settings.summaryElementId != '' && $('#' + this.settings.summaryElementId).length > 0) {
276                    /* $('#'+this.settings.summaryElementId).html(''); */
277                }
278                var obj = this,
279                    field = obj.field,
280                    errorClass = "errorlist",
281                    errorlist = $(document.createElement("ul")).addClass(errorClass).addClass(clname),
282                    types = {};
283                if (jQuery(field).attr('data-fatreq')) {
284                    var s = eval('[' + jQuery(field).attr('data-fatreq') + ']');
285                    types = s[0];
286                }
287                errors = [];
288                jQuery.each(types, function(rname, rval) {
289                    if (rname != 'customMessage') {
290                        var rule = $.Validation.getRule(rname);
291                        var fldval = $.trim(field.val());
292                        if (field.attr('data-fatdateformat') && 'range' == rname) {
293                            rval.dateFormat = field.attr('data-fatdateformat');
294                        }
295                        if (field.attr('type')) {
296                            if (field.attr('type').toLowerCase() === 'checkbox') {
297                                if (field.attr('name').indexOf('[') > 0 && rname == 'selectionrange') {
298                                    var arrayFieldNamePre = field.attr('name');
299                                    arrayFieldNamePre = arrayFieldNamePre.substring(0, arrayFieldNamePre.indexOf('[') + 1);
300                                    fldval = $(field).parents('form').find('input[name^="' + arrayFieldNamePre + '"]:checked').length;
301                                } else {
302                                    fldval = (field.is(':checked')) ? fldval : '';
303                                }
304                            }
305                        }
306                        if (rname == 'comparewith') {
307                            for (x in rval) {
308                                if (field.attr('data-fatdateformat')) {
309                                    rval[x].dateFormat = field.attr('data-fatdateformat');
310                                }
311                                var validvalue = rule.check($(field).parents('form').find('[name=' + rval[x].fldname + ']').val(), fldval, rval[x]);
312                                if (!validvalue)
313                                    break;
314                            }
315                        } else {
316                            var validvalue = rule.check(rval, fldval);
317                        }
318                        if (!validvalue) {
319                            field.addClass("error");
320                            if (types.customMessage) {
321                                msg = types.customMessage;
322                            } else {
323                                if (rname == 'comparewith') {
324                                    msg = $.Validation.getMessage(rname + '_' + rval[x].operator);
325                                    msg = msg.replace("{comparefield}", $(field).parents('form').find('[name=' + rval[x].fldname + ']').attr('data-field-caption'));
326                                } else {
327                                    msg = $.Validation.getMessage(rname);
328                                }
329                            }
330                            msg = msg.replace("{caption}", $(field).attr('data-field-caption'));
331                            if (jQuery.isArray(rval) && rval.length == 2) {
332                                msg = msg.replace("{minval}", rval[0]);
333                                msg = msg.replace("{minlength}", rval[0]);
334                                msg = msg.replace("{maxval}", rval[1]);
335                                msg = msg.replace("{maxlength}", rval[1]);
336                            }
337                            if (rname == 'range') {
338                                msg = msg.replace("{minval}", rval.minval);
339                                msg = msg.replace("{maxval}", rval.maxval);
340                            }
341                            if (types.customMessage) {
342                                errors = [];
343                            }
344                            errors.push(msg);
345                        }
346                    }
347                });
348                if (errors.length) {
349                    if (this.settings.errordisplay != 0 && this.settings.errordisplay != 1) {
350                        obj.field.unbind("keyup");
351                        obj.attach("keyup");
352                    }
353                    switch (this.settings.errordisplay) {
354                        case 1:
355                            $('#' + this.settings.summaryElementId).append(errorlist.empty());
356                            document.getElementById(this.settings.summaryElementId).scrollIntoView();
357                            break;
358                        case 2:
359                            if (field.attr('type') && field.attr('type').toLowerCase() === 'checkbox') {
360                                if (field.parents('.form__list--check').length > 0) {
361                                    field.parents('.form__list--check').before(errorlist.empty());
362                                } else {
363                                    field.parent().before(errorlist.empty());
364                                }
365                            } else {
366                                field.before(errorlist.empty());
367                            }
368                            break;
369                        case 3:
370                            if (field.attr('type') && field.attr('type').toLowerCase() === 'checkbox') {
371                                if (field.parents('.form__list--check').length > 0) {
372                                    field.parents('.form__list--check').find('ul').after(errorlist.empty());
373                                } else {
374                                    field.parent().before(errorlist.empty());
375                                }
376                            } else {
377                                field.after(errorlist.empty());
378                            }
379                            break;
380                        case 0:
381                            break;
382                    }
383                    for (error in errors) {
384                        if (this.settings.errordisplay == 0) {
385                            alert(errors[error]);
386                            return;
387                        } else {
388                            var li = $(document.createElement('li')).append($(document.createElement('a')).html(errors[error]).attr({ 'href': 'javascript:void(0);' }).bind('click', function() {
389                                $(field).focus();
390                            }));
391                            if (this.settings.errordisplay == 1) {
392                                $('#' + this.settings.summaryElementId).append(li.appendTo(errorlist));
393                            } else {
394                                li.appendTo(errorlist);
395                            }
396                        }
397                    }
398                    obj.valid = false;
399                } else {
400                    errorlist.remove();
401                    field.removeClass("error");
402                    obj.valid = true;
403                }
404                if (this.field.attr('data-mbsunichk')) {
405                    if (this.field.attr('data-mbsunichk') == '2') {
406                        obj.valid = false;
407                        if (!this.field.hasClass('field-processing'))
408                            this.field.trigger('change');
409                    }
410                }
411            }
412        }
413        /*
414         Validation extends jQuery prototype
415         */
416    $.extend($.fn, {
417        validation: function(options) {
418            $('[data-fat-req-change]', $(this)).each(function() {
419                $(this).trigger('change');
420            });
421            var validator = new Form($(this), options);
422            $.data($(this)[0], 'validator', validator);
423            var $this = $(this);
424            $(this).bind("submit", function(e) {
425                if ($this.hasClass('data-fat-submitted')) {
426                    e.preventDefault();
427                    console.log('Prevented resubmit of form.');
428                    return;
429                }
430                validator.validate();
431                if (!validator.isValid()) {
432                    e.preventDefault();
433                } else {
434                    $this.addClass('data-fat-submitted');
435                    setTimeout(function() {
436                        $this.removeClass('data-fat-submitted');
437                    }, 3000);
438                }
439            });
440            return validator;
441        },
442        validate: function() {
443            var validator = $.data($(this)[0], 'validator');
444            validator.validate();
445            return validator.isValid();
446        }
447    });
448    $.Validation = new Validation();
449})(jQuery);
450(function() {
451    checkUnique = function(fld, tbl, tbl_fld, tbl_key, key_fld, constraints) {
452        fld.removeClass('field-unique-error');
453        fld.removeClass('field-unique-success');
454        fld.addClass('field-processing');
455        var entered = fld.val();
456        $.ajax({
457            url: fcom.makeUrl('checkunique', 'check'),
458            type: 'POST',
459            dataType: 'json',
460            data: { 'val': entered, 'tbl': tbl, 'tbl_fld': tbl_fld, 'tbl_key': tbl_key, 'key_val': key_fld.val(), 'constraints': constraints },
461            success: function(ans) {
462                fld.removeClass('field-processing');
463                $(fld).attr('data-mbsunichk', 1);
464                if (ans.status == 0) {
465                    fld.addClass('field-unique-error');
466                    checkUniqueErrorNotify(fld.attr('data-field-caption'), entered);
467                    fld.val(ans.existing_value);
468                    fld.focus();
469                }
470                if (ans.status == 1) {
471                    fld.addClass('field-unique-success');
472                }
473            }
474        });
475        fld.bind('keyup', function(event) {
476            $(this).removeClass('field-unique-error');
477            $(this).removeClass('field-unique-success');
478            $(this).unbind(event);
479        });
480    }
481    fatUpdateRequirement = function(el) {
482        el = $(el);
483        var str = el.attr('data-fat-req-change');
484        if (!str)
485            return;
486        var arr = JSON.parse(str);
487        var v = el.val();
488        if (el.attr('type') == 'checkbox' && !el.is(':checked')) {
489            v = '';
490        }
491        for (var i = arr.length - 1; i >= 0; i--) {
492            var match = false;
493            switch (arr[i].operator) {
494                case 'eq':
495                    match = (v == arr[i].val);
496                    break;
497                case 'ne':
498                    match = (v != arr[i].val);
499                    break;
500                case 'gt':
501                    match = (v > arr[i].val);
502                    break;
503                case 'lt':
504                    match = (v < arr[i].val);
505                    break;
506                case 'ge':
507                    match = (v >= arr[i].val);
508                    break;
509                case 'le':
510                    match = (v <= arr[i].val);
511                    break;
512            }
513            if (!match)
514                continue;
515            $(el[0].form.elements[arr[i].fldname]).attr('data-fatreq', JSON.stringify(arr[i].requirement));
516        }
517    };
518    checkUniqueErrorNotify = function(caption, value) {
519        fcom.error(caption + " '" + value + "' " + langLbl.isNotAvailable);
520    };
521})();

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.