https://quorumapp.com/node_modules/jQuery-QueryBuilder/dist/js/query-builder.standalone.js

1/*!
2 * jQuery.extendext 1.0.0
3 *
4 * Copyright 2014-2019 Damien "Mistic" Sorel (http://www.strangeplanet.fr)
5 * Licensed under MIT (http://opensource.org/licenses/MIT)
6 * 
7 * Based on jQuery.extend by jQuery Foundation, Inc. and other contributors
8 */
9
10(function (root, factory) {
11    if (typeof define === 'function' && define.amd) {
12        define('jquery-extendext', ['jquery'], factory);
13    }
14    else if (typeof module === 'object' && module.exports) {
15        module.exports = factory(require('jquery'));
16    }
17    else {
18        factory(root.jQuery);
19    }
20}(this, function ($) {
21    "use strict";
22
23    $.extendext = function () {
24        var options, name, src, copy, copyIsArray, clone,
25            target = arguments[0] || {},
26            i = 1,
27            length = arguments.length,
28            deep = false,
29            arrayMode = 'default';
30
31        // Handle a deep copy situation
32        if (typeof target === "boolean") {
33            deep = target;
34
35            // Skip the boolean and the target
36            target = arguments[i++] || {};
37        }
38
39        // Handle array mode parameter
40        if (typeof target === "string") {
41            arrayMode = target.toLowerCase();
42            if (arrayMode !== 'concat' && arrayMode !== 'replace' && arrayMode !== 'extend') {
43                arrayMode = 'default';
44            }
45
46            // Skip the string param
47            target = arguments[i++] || {};
48        }
49
50        // Handle case when target is a string or something (possible in deep copy)
51        if (typeof target !== "object" && !$.isFunction(target)) {
52            target = {};
53        }
54
55        // Extend jQuery itself if only one argument is passed
56        if (i === length) {
57            target = this;
58            i--;
59        }
60
61        for (; i < length; i++) {
62            // Only deal with non-null/undefined values
63            if ((options = arguments[i]) !== null) {
64                // Special operations for arrays
65                if ($.isArray(options) && arrayMode !== 'default') {
66                    clone = target && $.isArray(target) ? target : [];
67
68                    switch (arrayMode) {
69                    case 'concat':
70                        target = clone.concat($.extend(deep, [], options));
71                        break;
72
73                    case 'replace':
74                        target = $.extend(deep, [], options);
75                        break;
76
77                    case 'extend':
78                        options.forEach(function (e, i) {
79                            if (typeof e === 'object') {
80                                var type = $.isArray(e) ? [] : {};
81                                clone[i] = $.extendext(deep, arrayMode, clone[i] || type, e);
82
83                            } else if (clone.indexOf(e) === -1) {
84                                clone.push(e);
85                            }
86                        });
87
88                        target = clone;
89                        break;
90                    }
91
92                } else {
93                    // Extend the base object
94                    for (name in options) {
95                        copy = options[name];
96
97                        // Prevent never-ending loop
98                        if (name === '__proto__' || target === copy) {
99                            continue;
100                        }
101
102                        // Recurse if we're merging plain objects or arrays
103                        if (deep && copy && ( $.isPlainObject(copy) ||
104                            (copyIsArray = $.isArray(copy)) )) {
105                            src = target[name];
106
107                            // Ensure proper type for the source value
108                            if ( copyIsArray && !Array.isArray( src ) ) {
109                                clone = [];
110                            } else if ( !copyIsArray && !$.isPlainObject( src ) ) {
111                                clone = {};
112                            } else {
113                                clone = src;
114                            }
115                            copyIsArray = false;
116
117                            // Never move original objects, clone them
118                            target[name] = $.extendext(deep, arrayMode, clone, copy);
119
120                            // Don't bring in undefined values
121                        } else if (copy !== undefined) {
122                            target[name] = copy;
123                        }
124                    }
125                }
126            }
127        }
128
129        // Return the modified object
130        return target;
131    };
132}));
133
134
135/*!
136 * jQuery QueryBuilder 2.7.0
137 * Copyright 2014-2023 Damien "Mistic" Sorel (http://www.strangeplanet.fr)
138 * Licensed under MIT (https://opensource.org/licenses/MIT)
139 */
140
141(function(root, factory) {
142    if (typeof define == 'function' && define.amd) {
143        define('query-builder', ['jquery', 'jquery-extendext'], factory);
144    }
145    else if (typeof module === 'object' && module.exports) {
146        module.exports = factory(require('jquery'), require('jquery-extendext'));
147    }
148    else {
149        factory(root.jQuery);
150    }
151}(this, function($) {
152"use strict";
153
154/**
155 * @typedef {object} Filter
156 * @memberof QueryBuilder
157 * @description See {@link http://querybuilder.js.org/index.html#filters}
158 */
159
160/**
161 * @typedef {object} Operator
162 * @memberof QueryBuilder
163 * @description See {@link http://querybuilder.js.org/index.html#operators}
164 */
165
166/**
167 * @param {jQuery} $el
168 * @param {object} options - see {@link http://querybuilder.js.org/#options}
169 * @constructor
170 */
171var QueryBuilder = function($el, options) {
172    $el[0].queryBuilder = this;
173
174    /**
175     * Element container
176     * @member {jQuery}
177     * @readonly
178     */
179    this.$el = $el;
180
181    /**
182     * Configuration object
183     * @member {object}
184     * @readonly
185     */
186    this.settings = $.extendext(true, 'replace', {}, QueryBuilder.DEFAULTS, options);
187
188    /**
189     * Internal model
190     * @member {Model}
191     * @readonly
192     */
193    this.model = new Model();
194
195    /**
196     * Internal status
197     * @member {object}
198     * @property {string} id - id of the container
199     * @property {boolean} generated_id - if the container id has been generated
200     * @property {int} group_id - current group id
201     * @property {int} rule_id - current rule id
202     * @property {boolean} has_optgroup - if filters have optgroups
203     * @property {boolean} has_operator_optgroup - if operators have optgroups
204     * @readonly
205     * @private
206     */
207    this.status = {
208        id: null,
209        generated_id: false,
210        group_id: 0,
211        rule_id: 0,
212        has_optgroup: false,
213        has_operator_optgroup: false
214    };
215
216    /**
217     * List of filters
218     * @member {QueryBuilder.Filter[]}
219     * @readonly
220     */
221    this.filters = this.settings.filters;
222
223    /**
224     * List of icons
225     * @member {object.<string, string>}
226     * @readonly
227     */
228    this.icons = this.settings.icons;
229
230    /**
231     * List of operators
232     * @member {QueryBuilder.Operator[]}
233     * @readonly
234     */
235    this.operators = this.settings.operators;
236
237    /**
238     * List of templates
239     * @member {object.<string, function>}
240     * @readonly
241     */
242    this.templates = this.settings.templates;
243
244    /**
245     * Plugins configuration
246     * @member {object.<string, object>}
247     * @readonly
248     */
249    this.plugins = this.settings.plugins;
250
251    /**
252     * Translations object
253     * @member {object}
254     * @readonly
255     */
256    this.lang = null;
257
258    // translations : english << 'lang_code' << custom
259    if (QueryBuilder.regional['en'] === undefined) {
260        Utils.error('Config', '"i18n/en.js" not loaded.');
261    }
262    this.lang = $.extendext(true, 'replace', {}, QueryBuilder.regional['en'], QueryBuilder.regional[this.settings.lang_code], this.settings.lang);
263
264    // "allow_groups" can be boolean or int
265    if (this.settings.allow_groups === false) {
266        this.settings.allow_groups = 0;
267    }
268    else if (this.settings.allow_groups === true) {
269        this.settings.allow_groups = -1;
270    }
271
272    // init templates
273    Object.keys(this.templates).forEach(function(tpl) {
274        if (!this.templates[tpl]) {
275            this.templates[tpl] = QueryBuilder.templates[tpl];
276        }
277        if (typeof this.templates[tpl] !== 'function') {
278            throw new Error(`Template ${tpl} must be a function`);
279        }
280    }, this);
281
282    // ensure we have a container id
283    if (!this.$el.attr('id')) {
284        this.$el.attr('id', 'qb_' + Math.floor(Math.random() * 99999));
285        this.status.generated_id = true;
286    }
287    this.status.id = this.$el.attr('id');
288
289    // INIT
290    this.$el.addClass('query-builder form-inline');
291
292    this.filters = this.checkFilters(this.filters);
293    this.operators = this.checkOperators(this.operators);
294    this.bindEvents();
295    this.initPlugins();
296};
297
298$.extend(QueryBuilder.prototype, /** @lends QueryBuilder.prototype */ {
299    /**
300     * Triggers an event on the builder container
301     * @param {string} type
302     * @returns {$.Event}
303     */
304    trigger: function(type) {
305        var event = new $.Event(this._tojQueryEvent(type), {
306            builder: this
307        });
308
309        this.$el.triggerHandler(event, Array.prototype.slice.call(arguments, 1));
310
311        return event;
312    },
313
314    /**
315     * Triggers an event on the builder container and returns the modified value
316     * @param {string} type
317     * @param {*} value
318     * @returns {*}
319     */
320    change: function(type, value) {
321        var event = new $.Event(this._tojQueryEvent(type, true), {
322            builder: this,
323            value: value
324        });
325
326        this.$el.triggerHandler(event, Array.prototype.slice.call(arguments, 2));
327
328        return event.value;
329    },
330
331    /**
332     * Attaches an event listener on the builder container
333     * @param {string} type
334     * @param {function} cb
335     * @returns {QueryBuilder}
336     */
337    on: function(type, cb) {
338        this.$el.on(this._tojQueryEvent(type), cb);
339        return this;
340    },
341
342    /**
343     * Removes an event listener from the builder container
344     * @param {string} type
345     * @param {function} [cb]
346     * @returns {QueryBuilder}
347     */
348    off: function(type, cb) {
349        this.$el.off(this._tojQueryEvent(type), cb);
350        return this;
351    },
352
353    /**
354     * Attaches an event listener called once on the builder container
355     * @param {string} type
356     * @param {function} cb
357     * @returns {QueryBuilder}
358     */
359    once: function(type, cb) {
360        this.$el.one(this._tojQueryEvent(type), cb);
361        return this;
362    },
363
364    /**
365     * Appends `.queryBuilder` and optionally `.filter` to the events names
366     * @param {string} name
367     * @param {boolean} [filter=false]
368     * @returns {string}
369     * @private
370     */
371    _tojQueryEvent: function(name, filter) {
372        return name.split(' ').map(function(type) {
373            return type + '.queryBuilder' + (filter ? '.filter' : '');
374        }).join(' ');
375    }
376});
377
378
379/**
380 * Allowed types and their internal representation
381 * @type {object.<string, string>}
382 * @readonly
383 * @private
384 */
385QueryBuilder.types = {
386    'string':   'string',
387    'integer':  'number',
388    'double':   'number',
389    'date':     'datetime',
390    'time':     'datetime',
391    'datetime': 'datetime',
392    'boolean':  'boolean'
393};
394
395/**
396 * Allowed inputs
397 * @type {string[]}
398 * @readonly
399 * @private
400 */

496;
497
498/**
499 * Default configuration
500 * @type {object}
501 * @readonly
502 */
503QueryBuilder.DEFAULTS = {
504    filters: [],
505    plugins: [],
506
507    sort_filters: false,
508    display_errors: true,
509    allow_groups: -1,
510    allow_empty: false,
511    conditions: ['AND', 'OR'],
512    default_condition: 'AND',
513    inputs_separator: ' , ',
514    select_placeholder: '------',
515    display_empty_filter: true,
516    default_filter: null,
517    optgroups: {},
518
519    default_rule_flags: {
520        filter_readonly: false,
521        operator_readonly: false,
522        value_readonly: false,
523        no_delete: false
524    },
525
526    default_group_flags: {
527        condition_readonly: false,
528        no_add_rule: false,
529        no_add_group: false,
530        no_delete: false
531    },
532
533    templates: {
534        group: null,
535        rule: null,
536        filterSelect: null,
537        operatorSelect: null,
538        ruleValueSelect: null
539    },
540
541    lang_code: 'en',
542    lang: {},
543
544    operators: [
545        'equal',
546        'not_equal',
547        'in',
548        'not_in',
549        'less',
550        'less_or_equal',
551        'greater',
552        'greater_or_equal',
553        'between',
554        'not_between',
555        'begins_with',
556        'not_begins_with',
557        'contains',
558        'not_contains',
559        'ends_with',
560        'not_ends_with',
561        'is_empty',
562        'is_not_empty',
563        'is_null',
564        'is_not_null'
565    ],
566
567    icons: {
568        add_group:    'glyphicon glyphicon-plus-sign',
569        add_rule:     'glyphicon glyphicon-plus',
570        remove_group: 'glyphicon glyphicon-remove',
571        remove_rule:  'glyphicon glyphicon-remove',
572        error:        'glyphicon glyphicon-warning-sign'
573    }
574};
575
576
577/**
578 * @module plugins
579 */
580
581/**
582 * Definition of available plugins
583 * @type {object.<String, object>}
584 */
585QueryBuilder.plugins = {};
586
587/**
588 * Gets or extends the default configuration
589 * @param {object} [options] - new configuration
590 * @returns {undefined|object} nothing or configuration object (copy)
591 */
592QueryBuilder.defaults = function(options) {
593    if (typeof options == 'object') {
594        $.extendext(true, 'replace', QueryBuilder.DEFAULTS, options);
595    }
596    else if (typeof options == 'string') {
597        if (typeof QueryBuilder.DEFAULTS[options] == 'object') {
598            return $.extend(true, {}, QueryBuilder.DEFAULTS[options]);
599        }
600        else {
601            return QueryBuilder.DEFAULTS[options];
602        }
603    }
604    else {
605        return $.extend(true, {}, QueryBuilder.DEFAULTS);
606    }
607};
608
609/**
610 * Registers a new plugin
611 * @param {string} name
612 * @param {function} fct - init function
613 * @param {object} [def] - default options
614 */
615QueryBuilder.define = function(name, fct, def) {
616    QueryBuilder.plugins[name] = {
617        fct: fct,
618        def: def || {}
619    };
620};
621
622/**
623 * Adds new methods to QueryBuilder prototype
624 * @param {object.<string, function>} methods
625 */
626QueryBuilder.extend = function(methods) {
627    $.extend(QueryBuilder.prototype, methods);
628};
629
630/**
631 * Initializes plugins for an instance
632 * @throws ConfigError
633 * @private
634 */
635QueryBuilder.prototype.initPlugins = function() {
636    if (!this.plugins) {
637        return;
638    }
639
640    if ($.isArray(this.plugins)) {
641        var tmp = {};
642        this.plugins.forEach(function(plugin) {
643            tmp[plugin] = null;
644        });
645        this.plugins = tmp;
646    }
647
648    Object.keys(this.plugins).forEach(function(plugin) {
649        if (plugin in QueryBuilder.plugins) {
650            this.plugins[plugin] = $.extend(true, {},
651                QueryBuilder.plugins[plugin].def,
652                this.plugins[plugin] || {}
653            );
654
655            QueryBuilder.plugins[plugin].fct.call(this, this.plugins[plugin]);
656        }
657        else {
658            Utils.error('Config', 'Unable to find plugin "{0}"', plugin);
659        }
660    }, this);
661};
662
663/**
664 * Returns the config of a plugin, if the plugin is not loaded, returns the default config.
665 * @param {string} name
666 * @param {string} [property]
667 * @throws ConfigError
668 * @returns {*}
669 */
670QueryBuilder.prototype.getPluginOptions = function(name, property) {
671    var plugin;
672    if (this.plugins && this.plugins[name]) {
673        plugin = this.plugins[name];
674    }
675    else if (QueryBuilder.plugins[name]) {
676        plugin = QueryBuilder.plugins[name].def;
677    }
678
679    if (plugin) {
680        if (property) {
681            return plugin[property];
682        }
683        else {
684            return plugin;
685        }
686    }
687    else {
688        Utils.error('Config', 'Unable to find plugin "{0}"', name);
689    }
690};
691
692
693/**
694 * Final initialisation of the builder
695 * @param {object} [rules]
696 * @fires QueryBuilder.afterInit
697 * @private
698 */
699QueryBuilder.prototype.init = function(rules) {
700    /**
701     * When the initilization is done, just before creating the root group
702     * @event afterInit
703     * @memberof QueryBuilder
704     */
705    this.trigger('afterInit');
706
707    if (rules) {
708        this.setRules(rules);
709        delete this.settings.rules;
710    }
711    else {
712        this.setRoot(true);
713    }
714};
715
716/**
717 * Checks the configuration of each filter
718 * @param {QueryBuilder.Filter[]} filters
719 * @returns {QueryBuilder.Filter[]}
720 * @throws ConfigError
721 */
722QueryBuilder.prototype.checkFilters = function(filters) {
723    var definedFilters = [];
724
725    if (!filters || filters.length === 0) {
726        Utils.error('Config', 'Missing filters list');
727    }
728
729    filters.forEach(function(filter, i) {
730        if (!filter.id) {
731            Utils.error('Config', 'Missing filter {0} id', i);
732        }
733        if (definedFilters.indexOf(filter.id) != -1) {
734            Utils.error('Config', 'Filter "{0}" already defined', filter.id);
735        }
736        definedFilters.push(filter.id);
737
738        if (!filter.type) {
739            filter.type = 'string';
740        }
741        else if (!QueryBuilder.types[filter.type]) {
742            Utils.error('Config', 'Invalid type "{0}"', filter.type);
743        }
744
745        if (!filter.input) {
746            filter.input = QueryBuilder.types[filter.type] === 'number' ? 'number' : 'text';
747        }
748        else if (typeof filter.input != 'function' && QueryBuilder.inputs.indexOf(filter.input) == -1) {
749            Utils.error('Config', 'Invalid input "{0}"', filter.input);
750        }
751
752        if (filter.operators) {
753            filter.operators.forEach(function(operator) {
754                if (typeof operator != 'string') {
755                    Utils.error('Config', 'Filter operators must be global operators types (string)');
756                }
757            });
758        }
759
760        if (!filter.field) {
761            filter.field = filter.id;
762        }
763        if (!filter.label) {
764            filter.label = filter.field;
765        }
766
767        if (!filter.optgroup) {
768            filter.optgroup = null;
769        }
770        else {
771            this.status.has_optgroup = true;
772
773            // register optgroup if needed
774            if (!this.settings.optgroups[filter.optgroup]) {
775                this.settings.optgroups[filter.optgroup] = filter.optgroup;
776            }
777        }
778
779        switch (filter.input) {
780            case 'radio':
781            case 'checkbox':
782                if (!filter.values || filter.values.length < 1) {
783                    Utils.error('Config', 'Missing filter "{0}" values', filter.id);
784                }
785                break;
786
787            case 'select':
788                var cleanValues = [];
789                filter.has_optgroup = false;
790
791                Utils.iterateOptions(filter.values, function(value, label, optgroup) {
792                    cleanValues.push({
793                        value: value,
794                        label: label,
795                        optgroup: optgroup || null
796                    });
797
798                    if (optgroup) {
799                        filter.has_optgroup = true;
800
801                        // register optgroup if needed
802                        if (!this.settings.optgroups[optgroup]) {
803                            this.settings.optgroups[optgroup] = optgroup;
804                        }
805                    }
806                }.bind(this));
807
808                if (filter.has_optgroup) {
809                    filter.values = Utils.groupSort(cleanValues, 'optgroup');
810                }
811                else {
812                    filter.values = cleanValues;
813                }
814
815                if (filter.placeholder) {
816                    if (filter.placeholder_value === undefined) {
817                        filter.placeholder_value = -1;
818                    }
819
820                    filter.values.forEach(function(entry) {
821                        if (entry.value == filter.placeholder_value) {
822                            Utils.error('Config', 'Placeholder of filter "{0}" overlaps with one of its values', filter.id);
823                        }
824                    });
825                }
826                break;
827        }
828    }, this);
829
830    if (this.settings.sort_filters) {
831        if (typeof this.settings.sort_filters == 'function') {
832            filters.sort(this.settings.sort_filters);
833        }
834        else {
835            var self = this;
836            filters.sort(function(a, b) {
837                return self.translate(a.label).localeCompare(self.translate(b.label));
838            });
839        }
840    }
841
842    if (this.status.has_optgroup) {
843        filters = Utils.groupSort(filters, 'optgroup');
844    }
845
846    return filters;
847};
848
849/**
850 * Checks the configuration of each operator
851 * @param {QueryBuilder.Operator[]} operators
852 * @returns {QueryBuilder.Operator[]}
853 * @throws ConfigError
854 */
855QueryBuilder.prototype.checkOperators = function(operators) {
856    var definedOperators = [];
857
858    operators.forEach(function(operator, i) {
859        if (typeof operator == 'string') {
860            if (!QueryBuilder.OPERATORS[operator]) {
861                Utils.error('Config', 'Unknown operator "{0}"', operator);
862            }
863
864            operators[i] = operator = $.extendext(true, 'replace', {}, QueryBuilder.OPERATORS[operator]);
865        }
866        else {
867            if (!operator.type) {
868                Utils.error('Config', 'Missing "type" for operator {0}', i);
869            }
870
871            if (QueryBuilder.OPERATORS[operator.type]) {
872                operators[i] = operator = $.extendext(true, 'replace', {}, QueryBuilder.OPERATORS[operator.type], operator);
873            }
874
875            if (operator.nb_inputs === undefined || operator.apply_to === undefined) {
876                Utils.error('Config', 'Missing "nb_inputs" and/or "apply_to" for operator "{0}"', operator.type);
877            }
878        }
879
880        if (definedOperators.indexOf(operator.type) != -1) {
881            Utils.error('Config', 'Operator "{0}" already defined', operator.type);
882        }
883        definedOperators.push(operator.type);
884
885        if (!operator.optgroup) {
886            operator.optgroup = null;
887        }
888        else {
889            this.status.has_operator_optgroup = true;
890
891            // register optgroup if needed
892            if (!this.settings.optgroups[operator.optgroup]) {
893                this.settings.optgroups[operator.optgroup] = operator.optgroup;
894            }
895        }
896    }, this);
897
898    if (this.status.has_operator_optgroup) {
899        operators = Utils.groupSort(operators, 'optgroup');
900    }
901
902    return operators;
903};
904
905/**
906 * Adds all events listeners to the builder
907 * @private
908 */
909QueryBuilder.prototype.bindEvents = function() {
910    var self = this;
911    var Selectors = QueryBuilder.selectors;
912
913    // group condition change
914    this.$el.on('change.queryBuilder', Selectors.group_condition, function() {
915        if ($(this).is(':checked')) {
916            var $group = $(this).closest(Selectors.group_container);
917            self.getModel($group).condition = $(this).val();
918        }
919    });
920
921    // rule filter change
922    this.$el.on('change.queryBuilder', Selectors.rule_filter, function() {
923        var $rule = $(this).closest(Selectors.rule_container);
924        self.getModel($rule).filter = self.getFilterById($(this).val());
925    });
926
927    // rule operator change
928    this.$el.on('change.queryBuilder', Selectors.rule_operator, function() {
929        var $rule = $(this).closest(Selectors.rule_container);
930        self.getModel($rule).operator = self.getOperatorByType($(this).val());
931    });
932
933    // add rule button
934    this.$el.on('click.queryBuilder', Selectors.add_rule, function() {
935        var $group = $(this).closest(Selectors.group_container);
936        self.addRule(self.getModel($group));
937    });
938
939    // delete rule button
940    this.$el.on('click.queryBuilder', Selectors.delete_rule, function() {
941        var $rule = $(this).closest(Selectors.rule_container);
942        self.deleteRule(self.getModel($rule));
943    });
944
945    if (this.settings.allow_groups !== 0) {
946        // add group button
947        this.$el.on('click.queryBuilder', Selectors.add_group, function() {
948            var $group = $(this).closest(Selectors.group_container);
949            self.addGroup(self.getModel($group));
950        });
951
952        // delete group button
953        this.$el.on('click.queryBuilder', Selectors.delete_group, function() {
954            var $group = $(this).closest(Selectors.group_container);
955            self.deleteGroup(self.getModel($group));
956        });
957    }
958
959    // model events
960    this.model.on({
961        'drop': function(e, node) {
962            node.$el.remove();
963            self.refreshGroupsConditions();
964        },
965        'add': function(e, parent, node, index) {
966            if (index === 0) {
967                node.$el.prependTo(parent.$el.find('>' + QueryBuilder.selectors.rules_list));
968            }
969            else {
970                node.$el.insertAfter(parent.rules[index - 1].$el);
971            }
972            self.refreshGroupsConditions();
973        },
974        'move': function(e, node, group, index) {
975            node.$el.detach();
976
977            if (index === 0) {
978                node.$el.prependTo(group.$el.find('>' + QueryBuilder.selectors.rules_list));
979            }
980            else {
981                node.$el.insertAfter(group.rules[index - 1].$el);
982            }
983            self.refreshGroupsConditions();
984        },
985        'update': function(e, node, field, value, oldValue) {
986            if (node instanceof Rule) {
987                switch (field) {
988                    case 'error':
989                        self.updateError(node);
990                        break;
991
992                    case 'flags':
993                        self.applyRuleFlags(node);
994                        break;
995
996                    case 'filter':
997                        self.updateRuleFilter(node, oldValue);
998                        break;
999
1000                    case 'operator':
1001                        self.updateRuleOperator(node, oldValue);
1002                        break;
1003
1004                    case 'value':
1005                        self.updateRuleValue(node, oldValue);
1006                        break;
1007                }
1008            }
1009            else {
1010                switch (field) {
1011                    case 'error':
1012                        self.updateError(node);
1013                        break;
1014
1015                    case 'flags':
1016                        self.applyGroupFlags(node);
1017                        break;
1018
1019                    case 'condition':
1020                        self.updateGroupCondition(node, oldValue);
1021                        break;
1022                }
1023            }
1024        }
1025    });
1026};
1027
1028/**
1029 * Creates the root group
1030 * @param {boolean} [addRule=true] - adds a default empty rule
1031 * @param {object} [data] - group custom data
1032 * @param {object} [flags] - flags to apply to the group
1033 * @returns {Group} root group
1034 * @fires QueryBuilder.afterAddGroup
1035 */
1036QueryBuilder.prototype.setRoot = function(addRule, data, flags) {
1037    addRule = (addRule === undefined || addRule === true);
1038
1039    var group_id = this.nextGroupId();
1040    var $group = $($.parseHTML(this.getGroupTemplate(group_id, 1)));
1041
1042    this.$el.append($group);
1043    this.model.root = new Group(null, $group);
1044    this.model.root.model = this.model;
1045
1046    this.model.root.data = data;
1047    this.model.root.flags = $.extend({}, this.settings.default_group_flags, flags);
1048    this.model.root.condition = this.settings.default_condition;
1049
1050    this.trigger('afterAddGroup', this.model.root);
1051
1052    if (addRule) {
1053        this.addRule(this.model.root);
1054    }
1055
1056    return this.model.root;
1057};
1058
1059/**
1060 * Adds a new group
1061 * @param {Group} parent
1062 * @param {boolean} [addRule=true] - adds a default empty rule
1063 * @param {object} [data] - group custom data
1064 * @param {object} [flags] - flags to apply to the group
1065 * @returns {Group}
1066 * @fires QueryBuilder.beforeAddGroup
1067 * @fires QueryBuilder.afterAddGroup
1068 */
1069QueryBuilder.prototype.addGroup = function(parent, addRule, data, flags) {
1070    addRule = (addRule === undefined || addRule === true);
1071
1072    var level = parent.level + 1;
1073
1074    /**
1075     * Just before adding a group, can be prevented.
1076     * @event beforeAddGroup
1077     * @memberof QueryBuilder
1078     * @param {Group} parent
1079     * @param {boolean} addRule - if an empty rule will be added in the group
1080     * @param {int} level - nesting level of the group, 1 is the root group
1081     */
1082    var e = this.trigger('beforeAddGroup', parent, addRule, level);
1083    if (e.isDefaultPrevented()) {
1084        return null;
1085    }
1086
1087    var group_id = this.nextGroupId();
1088    var $group = $(this.getGroupTemplate(group_id, level));
1089    var model = parent.addGroup($group);
1090
1091    model.data = data;
1092    model.flags = $.extend({}, this.settings.default_group_flags, flags);
1093    model.condition = this.settings.default_condition;
1094
1095    /**
1096     * Just after adding a group
1097     * @event afterAddGroup
1098     * @memberof QueryBuilder
1099     * @param {Group} group
1100     */
1101    this.trigger('afterAddGroup', model);
1102
1103    /**
1104     * After any change in the rules
1105     * @event rulesChanged
1106     * @memberof QueryBuilder
1107     */
1108    this.trigger('rulesChanged');
1109
1110    if (addRule) {
1111        this.addRule(model);
1112    }
1113
1114    return model;
1115};
1116
1117/**
1118 * Tries to delete a group. The group is not deleted if at least one rule is flagged `no_delete`.
1119 * @param {Group} group
1120 * @returns {boolean} if the group has been deleted
1121 * @fires QueryBuilder.beforeDeleteGroup
1122 * @fires QueryBuilder.afterDeleteGroup
1123 */
1124QueryBuilder.prototype.deleteGroup = function(group) {
1125    if (group.isRoot()) {
1126        return false;
1127    }
1128
1129    /**
1130     * Just before deleting a group, can be prevented
1131     * @event beforeDeleteGroup
1132     * @memberof QueryBuilder
1133     * @param {Group} parent
1134     */
1135    var e = this.trigger('beforeDeleteGroup', group);
1136    if (e.isDefaultPrevented()) {
1137        return false;
1138    }
1139
1140    var del = true;
1141
1142    group.each('reverse', function(rule) {
1143        del &= this.deleteRule(rule);
1144    }, function(group) {
1145        del &= this.deleteGroup(group);
1146    }, this);
1147
1148    if (del) {
1149        group.drop();
1150
1151        /**
1152         * Just after deleting a group
1153         * @event afterDeleteGroup
1154         * @memberof QueryBuilder
1155         */
1156        this.trigger('afterDeleteGroup');
1157
1158        this.trigger('rulesChanged');
1159    }
1160
1161    return del;
1162};
1163
1164/**
1165 * Performs actions when a group's condition changes
1166 * @param {Group} group
1167 * @param {object} previousCondition
1168 * @fires QueryBuilder.afterUpdateGroupCondition
1169 * @private
1170 */
1171QueryBuilder.prototype.updateGroupCondition = function(group, previousCondition) {
1172    group.$el.find('>' + QueryBuilder.selectors.group_condition).each(function() {
1173        var $this = $(this);
1174        $this.prop('checked', $this.val() === group.condition);
1175        $this.parent().toggleClass('active', $this.val() === group.condition);
1176    });
1177
1178    /**
1179     * After the group condition has been modified
1180     * @event afterUpdateGroupCondition
1181     * @memberof QueryBuilder
1182     * @param {Group} group
1183     * @param {object} previousCondition
1184     */
1185    this.trigger('afterUpdateGroupCondition', group, previousCondition);
1186
1187    this.trigger('rulesChanged');
1188};
1189
1190/**
1191 * Updates the visibility of conditions based on number of rules inside each group
1192 * @private
1193 */
1194QueryBuilder.prototype.refreshGroupsConditions = function() {
1195    (function walk(group) {
1196        if (!group.flags || (group.flags && !group.flags.condition_readonly)) {
1197            group.$el.find('>' + QueryBuilder.selectors.group_condition).prop('disabled', group.rules.length <= 1)
1198                .parent().toggleClass('disabled', group.rules.length <= 1);
1199        }
1200
1201        group.each(null, function(group) {
1202            walk(group);
1203        }, this);
1204    }(this.model.root));
1205};
1206
1207/**
1208 * Adds a new rule
1209 * @param {Group} parent
1210 * @param {object} [data] - rule custom data
1211 * @param {object} [flags] - flags to apply to the rule
1212 * @returns {Rule}
1213 * @fires QueryBuilder.beforeAddRule
1214 * @fires QueryBuilder.afterAddRule
1215 * @fires QueryBuilder.changer:getDefaultFilter
1216 */
1217QueryBuilder.prototype.addRule = function(parent, data, flags) {
1218    /**
1219     * Just before adding a rule, can be prevented
1220     * @event beforeAddRule
1221     * @memberof QueryBuilder
1222     * @param {Group} parent
1223     */
1224    var e = this.trigger('beforeAddRule', parent);
1225    if (e.isDefaultPrevented()) {
1226        return null;
1227    }
1228
1229    var rule_id = this.nextRuleId();
1230    var $rule = $($.parseHTML(this.getRuleTemplate(rule_id)));
1231    var model = parent.addRule($rule);
1232
1233    model.data = data;
1234    model.flags = $.extend({}, this.settings.default_rule_flags, flags);
1235
1236    /**
1237     * Just after adding a rule
1238     * @event afterAddRule
1239     * @memberof QueryBuilder
1240     * @param {Rule} rule
1241     */
1242    this.trigger('afterAddRule', model);
1243
1244    this.trigger('rulesChanged');
1245
1246    this.createRuleFilters(model);
1247
1248    if (this.settings.default_filter || !this.settings.display_empty_filter) {
1249        /**
1250         * Modifies the default filter for a rule
1251         * @event changer:getDefaultFilter
1252         * @memberof QueryBuilder
1253         * @param {QueryBuilder.Filter} filter
1254         * @param {Rule} rule
1255         * @returns {QueryBuilder.Filter}
1256         */
1257        model.filter = this.change('getDefaultFilter',
1258            this.getFilterById(this.settings.default_filter || this.filters[0].id),
1259            model
1260        );
1261    }
1262
1263    return model;
1264};
1265
1266/**
1267 * Tries to delete a rule
1268 * @param {Rule} rule
1269 * @returns {boolean} if the rule has been deleted
1270 * @fires QueryBuilder.beforeDeleteRule
1271 * @fires QueryBuilder.afterDeleteRule
1272 */
1273QueryBuilder.prototype.deleteRule = function(rule) {
1274    if (rule.flags.no_delete) {
1275        return false;
1276    }
1277
1278    /**
1279     * Just before deleting a rule, can be prevented
1280     * @event beforeDeleteRule
1281     * @memberof QueryBuilder
1282     * @param {Rule} rule
1283     */
1284    var e = this.trigger('beforeDeleteRule', rule);
1285    if (e.isDefaultPrevented()) {
1286        return false;
1287    }
1288
1289    rule.drop();
1290
1291    /**
1292     * Just after deleting a rule
1293     * @event afterDeleteRule
1294     * @memberof QueryBuilder
1295     */
1296    this.trigger('afterDeleteRule');
1297
1298    this.trigger('rulesChanged');
1299
1300    return true;
1301};
1302
1303/**
1304 * Creates the filters for a rule
1305 * @param {Rule} rule
1306 * @fires QueryBuilder.changer:getRuleFilters
1307 * @fires QueryBuilder.afterCreateRuleFilters
1308 * @private
1309 */
1310QueryBuilder.prototype.createRuleFilters = function(rule) {
1311    /**
1312     * Modifies the list a filters available for a rule
1313     * @event changer:getRuleFilters
1314     * @memberof QueryBuilder
1315     * @param {QueryBuilder.Filter[]} filters
1316     * @param {Rule} rule
1317     * @returns {QueryBuilder.Filter[]}
1318     */
1319    var filters = this.change('getRuleFilters', this.filters, rule);
1320    var $filterSelect = $($.parseHTML(this.getRuleFilterSelect(rule, filters)));
1321
1322    rule.$el.find(QueryBuilder.selectors.filter_container).html($filterSelect);
1323
1324    /**
1325     * After creating the dropdown for filters
1326     * @event afterCreateRuleFilters
1327     * @memberof QueryBuilder
1328     * @param {Rule} rule
1329     */
1330    this.trigger('afterCreateRuleFilters', rule);
1331
1332    this.applyRuleFlags(rule);
1333};
1334
1335/**
1336 * Creates the operators for a rule and init the rule operator
1337 * @param {Rule} rule
1338 * @fires QueryBuilder.afterCreateRuleOperators
1339 * @private
1340 */
1341QueryBuilder.prototype.createRuleOperators = function(rule) {
1342    var $operatorContainer = rule.$el.find(QueryBuilder.selectors.operator_container).empty();
1343
1344    if (!rule.filter) {
1345        return;
1346    }
1347
1348    var operators = this.getOperators(rule.filter);
1349    var $operatorSelect = $($.parseHTML(this.getRuleOperatorSelect(rule, operators)));
1350
1351    $operatorContainer.html($operatorSelect);
1352
1353    // set the operator without triggering update event
1354    if (rule.filter.default_operator) {
1355        rule.__.operator = this.getOperatorByType(rule.filter.default_operator);
1356    }
1357    else {
1358        rule.__.operator = operators[0];
1359    }
1360
1361    rule.$el.find(QueryBuilder.selectors.rule_operator).val(rule.operator.type);
1362
1363    /**
1364     * After creating the dropdown for operators
1365     * @event afterCreateRuleOperators
1366     * @memberof QueryBuilder
1367     * @param {Rule} rule
1368     * @param {QueryBuilder.Operator[]} operators - allowed operators for this rule
1369     */
1370    this.trigger('afterCreateRuleOperators', rule, operators);
1371
1372    this.applyRuleFlags(rule);
1373};
1374
1375/**
1376 * Creates the main input for a rule
1377 * @param {Rule} rule
1378 * @fires QueryBuilder.afterCreateRuleInput
1379 * @private
1380 */
1381QueryBuilder.prototype.createRuleInput = function(rule) {
1382    var $valueContainer = rule.$el.find(QueryBuilder.selectors.value_container).empty();
1383
1384    rule.__.value = undefined;
1385
1386    if (!rule.filter || !rule.operator || rule.operator.nb_inputs === 0) {
1387        return;
1388    }
1389
1390    var self = this;
1391    var $inputs = $();
1392    var filter = rule.filter;
1393
1394    for (var i = 0; i < rule.operator.nb_inputs; i++) {
1395        var $ruleInput = $($.parseHTML($.trim(this.getRuleInput(rule, i))));
1396        if (i > 0) $valueContainer.append(this.settings.inputs_separator);
1397        $valueContainer.append($ruleInput);
1398        $inputs = $inputs.add($ruleInput);
1399    }
1400
1401    $valueContainer.css('display', '');
1402
1403    $inputs.on('change ' + (filter.input_event || ''), function() {
1404        if (!rule._updating_input) {
1405            rule._updating_value = true;
1406            rule.value = self.getRuleInputValue(rule);
1407            rule._updating_value = false;
1408        }
1409    });
1410
1411    if (filter.plugin) {
1412        $inputs[filter.plugin](filter.plugin_config || {});
1413    }
1414
1415    /**
1416     * After creating the input for a rule and initializing optional plugin
1417     * @event afterCreateRuleInput
1418     * @memberof QueryBuilder
1419     * @param {Rule} rule
1420     */
1421    this.trigger('afterCreateRuleInput', rule);
1422
1423    if (filter.default_value !== undefined) {
1424        rule.value = filter.default_value;
1425    }
1426    else {
1427        rule._updating_value = true;
1428        rule.value = self.getRuleInputValue(rule);
1429        rule._updating_value = false;
1430    }
1431
1432    this.applyRuleFlags(rule);
1433};
1434
1435/**
1436 * Performs action when a rule's filter changes
1437 * @param {Rule} rule
1438 * @param {object} previousFilter
1439 * @fires QueryBuilder.afterUpdateRuleFilter
1440 * @private
1441 */
1442QueryBuilder.prototype.updateRuleFilter = function(rule, previousFilter) {
1443    this.createRuleOperators(rule);
1444    this.createRuleInput(rule);
1445
1446    rule.$el.find(QueryBuilder.selectors.rule_filter).val(rule.filter ? rule.filter.id : '-1');
1447
1448    // clear rule data if the filter changed
1449    if (previousFilter && rule.filter && previousFilter.id !== rule.filter.id) {
1450        rule.data = undefined;
1451    }
1452
1453    /**
1454     * After the filter has been updated and the operators and input re-created
1455     * @event afterUpdateRuleFilter
1456     * @memberof QueryBuilder
1457     * @param {Rule} rule
1458     * @param {object} previousFilter
1459     */
1460    this.trigger('afterUpdateRuleFilter', rule, previousFilter);
1461
1462    this.trigger('rulesChanged');
1463};
1464
1465/**
1466 * Performs actions when a rule's operator changes
1467 * @param {Rule} rule
1468 * @param {object} previousOperator
1469 * @fires QueryBuilder.afterUpdateRuleOperator
1470 * @private
1471 */
1472QueryBuilder.prototype.updateRuleOperator = function(rule, previousOperator) {
1473    var $valueContainer = rule.$el.find(QueryBuilder.selectors.value_container);
1474
1475    if (!rule.operator || rule.operator.nb_inputs === 0) {
1476        $valueContainer.hide();
1477
1478        rule.__.value = undefined;
1479    }
1480    else {
1481        $valueContainer.css('display', '');
1482
1483        if ($valueContainer.is(':empty') || !previousOperator ||
1484            rule.operator.nb_inputs !== previousOperator.nb_inputs ||
1485            rule.operator.optgroup !== previousOperator.optgroup
1486        ) {
1487            this.createRuleInput(rule);
1488        }
1489    }
1490
1491    if (rule.operator) {
1492        rule.$el.find(QueryBuilder.selectors.rule_operator).val(rule.operator.type);
1493
1494        // refresh value if the format changed for this operator
1495        rule.__.value = this.getRuleInputValue(rule);
1496    }
1497
1498    /**
1499     *  After the operator has been updated and the input optionally re-created
1500     * @event afterUpdateRuleOperator
1501     * @memberof QueryBuilder
1502     * @param {Rule} rule
1503     * @param {object} previousOperator
1504     */
1505    this.trigger('afterUpdateRuleOperator', rule, previousOperator);
1506
1507    this.trigger('rulesChanged');
1508};
1509
1510/**
1511 * Performs actions when rule's value changes
1512 * @param {Rule} rule
1513 * @param {object} previousValue
1514 * @fires QueryBuilder.afterUpdateRuleValue
1515 * @private
1516 */
1517QueryBuilder.prototype.updateRuleValue = function(rule, previousValue) {
1518    if (!rule._updating_value) {
1519        this.setRuleInputValue(rule, rule.value);
1520    }
1521
1522    /**
1523     * After the rule value has been modified
1524     * @event afterUpdateRuleValue
1525     * @memberof QueryBuilder
1526     * @param {Rule} rule
1527     * @param {*} previousValue
1528     */
1529    this.trigger('afterUpdateRuleValue', rule, previousValue);
1530
1531    this.trigger('rulesChanged');
1532};
1533
1534/**
1535 * Changes a rule's properties depending on its flags
1536 * @param {Rule} rule
1537 * @fires QueryBuilder.afterApplyRuleFlags
1538 * @private
1539 */
1540QueryBuilder.prototype.applyRuleFlags = function(rule) {
1541    var flags = rule.flags;
1542    var Selectors = QueryBuilder.selectors;
1543
1544    rule.$el.find(Selectors.rule_filter).prop('disabled', flags.filter_readonly);
1545    rule.$el.find(Selectors.rule_operator).prop('disabled', flags.operator_readonly);
1546    rule.$el.find(Selectors.rule_value).prop('disabled', flags.value_readonly);
1547
1548    if (flags.no_delete) {
1549        rule.$el.find(Selectors.delete_rule).remove();
1550    }
1551
1552    /**
1553     * After rule's flags has been applied
1554     * @event afterApplyRuleFlags
1555     * @memberof QueryBuilder
1556     * @param {Rule} rule
1557     */
1558    this.trigger('afterApplyRuleFlags', rule);
1559};
1560
1561/**
1562 * Changes group's properties depending on its flags
1563 * @param {Group} group
1564 * @fires QueryBuilder.afterApplyGroupFlags
1565 * @private
1566 */
1567QueryBuilder.prototype.applyGroupFlags = function(group) {
1568    var flags = group.flags;
1569    var Selectors = QueryBuilder.selectors;
1570
1571    group.$el.find('>' + Selectors.group_condition).prop('disabled', flags.condition_readonly)
1572        .parent().toggleClass('readonly', flags.condition_readonly);
1573
1574    if (flags.no_add_rule) {
1575        group.$el.find(Selectors.add_rule).remove();
1576    }
1577    if (flags.no_add_group) {
1578        group.$el.find(Selectors.add_group).remove();
1579    }
1580    if (flags.no_delete) {
1581        group.$el.find(Selectors.delete_group).remove();
1582    }
1583
1584    /**
1585     * After group's flags has been applied
1586     * @event afterApplyGroupFlags
1587     * @memberof QueryBuilder
1588     * @param {Group} group
1589     */
1590    this.trigger('afterApplyGroupFlags', group);
1591};
1592
1593/**
1594 * Clears all errors markers
1595 * @param {Node} [node] default is root Group
1596 */
1597QueryBuilder.prototype.clearErrors = function(node) {
1598    node = node || this.model.root;
1599
1600    if (!node) {
1601        return;
1602    }
1603
1604    node.error = null;
1605
1606    if (node instanceof Group) {
1607        node.each(function(rule) {
1608            rule.error = null;
1609        }, function(group) {
1610            this.clearErrors(group);
1611        }, this);
1612    }
1613};
1614
1615/**
1616 * Adds/Removes error on a Rule or Group
1617 * @param {Node} node
1618 * @fires QueryBuilder.changer:displayError
1619 * @private
1620 */
1621QueryBuilder.prototype.updateError = function(node) {
1622    if (this.settings.display_errors) {
1623        if (node.error === null) {
1624            node.$el.removeClass('has-error');
1625        }
1626        else {
1627            var errorMessage = this.translate('errors', node.error[0]);
1628            errorMessage = Utils.fmt(errorMessage, node.error.slice(1));
1629
1630            /**
1631             * Modifies an error message before display
1632             * @event changer:displayError
1633             * @memberof QueryBuilder
1634             * @param {string} errorMessage - the error message (translated and formatted)
1635             * @param {array} error - the raw error array (error code and optional arguments)
1636             * @param {Node} node
1637             * @returns {string}
1638             */
1639            errorMessage = this.change('displayError', errorMessage, node.error, node);
1640
1641            node.$el.addClass('has-error')
1642                .find(QueryBuilder.selectors.error_container).eq(0)
1643                .attr('title', errorMessage);
1644        }
1645    }
1646};
1647
1648/**
1649 * Triggers a validation error event
1650 * @param {Node} node
1651 * @param {string|array} error
1652 * @param {*} value
1653 * @fires QueryBuilder.validationError
1654 * @private
1655 */
1656QueryBuilder.prototype.triggerValidationError = function(node, error, value) {
1657    if (!$.isArray(error)) {
1658        error = [error];
1659    }
1660
1661    /**
1662     * Fired when a validation error occurred, can be prevented
1663     * @event validationError
1664     * @memberof QueryBuilder
1665     * @param {Node} node
1666     * @param {string} error
1667     * @param {*} value
1668     */
1669    var e = this.trigger('validationError', node, error, value);
1670    if (!e.isDefaultPrevented()) {
1671        node.error = error;
1672    }
1673};
1674
1675
1676/**
1677 * Destroys the builder
1678 * @fires QueryBuilder.beforeDestroy
1679 */
1680QueryBuilder.prototype.destroy = function() {
1681    /**
1682     * Before the {@link QueryBuilder#destroy} method
1683     * @event beforeDestroy
1684     * @memberof QueryBuilder
1685     */
1686    this.trigger('beforeDestroy');
1687
1688    if (this.status.generated_id) {
1689        this.$el.removeAttr('id');
1690    }
1691
1692    this.clear();
1693    this.model = null;
1694
1695    this.$el
1696        .off('.queryBuilder')
1697        .removeClass('query-builder')
1698        .removeData('queryBuilder');
1699
1700    delete this.$el[0].queryBuilder;
1701};
1702
1703/**
1704 * Clear all rules and resets the root group
1705 * @fires QueryBuilder.beforeReset
1706 * @fires QueryBuilder.afterReset
1707 */
1708QueryBuilder.prototype.reset = function() {
1709    /**
1710     * Before the {@link QueryBuilder#reset} method, can be prevented
1711     * @event beforeReset
1712     * @memberof QueryBuilder
1713     */
1714    var e = this.trigger('beforeReset');
1715    if (e.isDefaultPrevented()) {
1716        return;
1717    }
1718
1719    this.status.group_id = 1;
1720    this.status.rule_id = 0;
1721
1722    this.model.root.empty();
1723
1724    this.model.root.data = undefined;
1725    this.model.root.flags = $.extend({}, this.settings.default_group_flags);
1726    this.model.root.condition = this.settings.default_condition;
1727
1728    this.addRule(this.model.root);
1729
1730    /**
1731     * After the {@link QueryBuilder#reset} method
1732     * @event afterReset
1733     * @memberof QueryBuilder
1734     */
1735    this.trigger('afterReset');
1736
1737    this.trigger('rulesChanged');
1738};
1739
1740/**
1741 * Clears all rules and removes the root group
1742 * @fires QueryBuilder.beforeClear
1743 * @fires QueryBuilder.afterClear
1744 */
1745QueryBuilder.prototype.clear = function() {
1746    /**
1747     * Before the {@link QueryBuilder#clear} method, can be prevented
1748     * @event beforeClear
1749     * @memberof QueryBuilder
1750     */
1751    var e = this.trigger('beforeClear');
1752    if (e.isDefaultPrevented()) {
1753        return;
1754    }
1755
1756    this.status.group_id = 0;
1757    this.status.rule_id = 0;
1758
1759    if (this.model.root) {
1760        this.model.root.drop();
1761        this.model.root = null;
1762    }
1763
1764    /**
1765     * After the {@link QueryBuilder#clear} method
1766     * @event afterClear
1767     * @memberof QueryBuilder
1768     */
1769    this.trigger('afterClear');
1770
1771    this.trigger('rulesChanged');
1772};
1773
1774/**
1775 * Modifies the builder configuration.<br>
1776 * Only options defined in QueryBuilder.modifiable_options are modifiable
1777 * @param {object} options
1778 */
1779QueryBuilder.prototype.setOptions = function(options) {
1780    $.each(options, function(opt, value) {
1781        if (QueryBuilder.modifiable_options.indexOf(opt) !== -1) {
1782            this.settings[opt] = value;
1783        }
1784    }.bind(this));
1785};
1786
1787/**
1788 * Returns the model associated to a DOM object, or the root model
1789 * @param {jQuery} [target]
1790 * @returns {Node}
1791 */
1792QueryBuilder.prototype.getModel = function(target) {
1793    if (!target) {
1794        return this.model.root;
1795    }
1796    else if (target instanceof Node) {
1797        return target;
1798    }
1799    else {
1800        return $(target).data('queryBuilderModel');
1801    }
1802};
1803
1804/**
1805 * Validates the whole builder
1806 * @param {object} [options]
1807 * @param {boolean} [options.skip_empty=false] - skips validating rules that have no filter selected
1808 * @returns {boolean}
1809 * @fires QueryBuilder.changer:validate
1810 */
1811QueryBuilder.prototype.validate = function(options) {
1812    options = $.extend({
1813        skip_empty: false
1814    }, options);
1815
1816    this.clearErrors();
1817
1818    var self = this;
1819
1820    var valid = (function parse(group) {
1821        var done = 0;
1822        var errors = 0;
1823
1824        group.each(function(rule) {
1825            if (!rule.filter && options.skip_empty) {
1826                return;
1827            }
1828
1829            if (!rule.filter) {
1830                self.triggerValidationError(rule, 'no_filter', null);
1831                errors++;
1832                return;
1833            }
1834
1835            if (!rule.operator) {
1836                self.triggerValidationError(rule, 'no_operator', null);
1837                errors++;
1838                return;
1839            }
1840
1841            if (rule.operator.nb_inputs !== 0) {
1842                var valid = self.validateValue(rule, rule.value);
1843
1844                if (valid !== true) {
1845                    self.triggerValidationError(rule, valid, rule.value);
1846                    errors++;
1847                    return;
1848                }
1849            }
1850
1851            done++;
1852
1853        }, function(group) {
1854            var res = parse(group);
1855            if (res === true) {
1856                done++;
1857            }
1858            else if (res === false) {
1859                errors++;
1860            }
1861        });
1862
1863        if (errors > 0) {
1864            return false;
1865        }
1866        else if (done === 0 && !group.isRoot() && options.skip_empty) {
1867            return null;
1868        }
1869        else if (done === 0 && (!self.settings.allow_empty || !group.isRoot())) {
1870            self.triggerValidationError(group, 'empty_group', null);
1871            return false;
1872        }
1873
1874        return true;
1875
1876    }(this.model.root));
1877
1878    /**
1879     * Modifies the result of the {@link QueryBuilder#validate} method
1880     * @event changer:validate
1881     * @memberof QueryBuilder
1882     * @param {boolean} valid
1883     * @returns {boolean}
1884     */
1885    return this.change('validate', valid);
1886};
1887
1888/**
1889 * Gets an object representing current rules
1890 * @param {object} [options]
1891 * @param {boolean|string} [options.get_flags=false] - export flags, true: only changes from default flags or 'all'
1892 * @param {boolean} [options.allow_invalid=false] - returns rules even if they are invalid
1893 * @param {boolean} [options.skip_empty=false] - remove rules that have no filter selected
1894 * @returns {object}
1895 * @fires QueryBuilder.changer:ruleToJson
1896 * @fires QueryBuilder.changer:groupToJson
1897 * @fires QueryBuilder.changer:getRules
1898 */
1899QueryBuilder.prototype.getRules = function(options) {
1900    options = $.extend({
1901        get_flags: false,
1902        allow_invalid: false,
1903        skip_empty: false
1904    }, options);
1905
1906    var valid = this.validate(options);
1907    if (!valid && !options.allow_invalid) {
1908        return null;
1909    }
1910
1911    var self = this;
1912
1913    var out = (function parse(group) {
1914        var groupData = {
1915            condition: group.condition,
1916            rules: []
1917        };
1918
1919        if (group.data) {
1920            groupData.data = $.extendext(true, 'replace', {}, group.data);
1921        }
1922
1923        if (options.get_flags) {
1924            var flags = self.getGroupFlags(group.flags, options.get_flags === 'all');
1925            if (!$.isEmptyObject(flags)) {
1926                groupData.flags = flags;
1927            }
1928        }
1929
1930        group.each(function(rule) {
1931            if (!rule.filter && options.skip_empty) {
1932                return;
1933            }
1934
1935            var value = null;
1936            if (!rule.operator || rule.operator.nb_inputs !== 0) {
1937                value = rule.value;
1938            }
1939
1940            var ruleData = {
1941                id: rule.filter ? rule.filter.id : null,
1942                field: rule.filter ? rule.filter.field : null,
1943                type: rule.filter ? rule.filter.type : null,
1944                input: rule.filter ? rule.filter.input : null,
1945                operator: rule.operator ? rule.operator.type : null,
1946                value: value
1947            };
1948
1949            if (rule.filter && rule.filter.data || rule.data) {
1950                ruleData.data = $.extendext(true, 'replace', {}, rule.filter ? rule.filter.data : {}, rule.data);
1951            }
1952
1953            if (options.get_flags) {
1954                var flags = self.getRuleFlags(rule.flags, options.get_flags === 'all');
1955                if (!$.isEmptyObject(flags)) {
1956                    ruleData.flags = flags;
1957                }
1958            }
1959
1960            /**
1961             * Modifies the JSON generated from a Rule object
1962             * @event changer:ruleToJson
1963             * @memberof QueryBuilder
1964             * @param {object} json
1965             * @param {Rule} rule
1966             * @returns {object}
1967             */
1968            groupData.rules.push(self.change('ruleToJson', ruleData, rule));
1969
1970        }, function(model) {
1971            var data = parse(model);
1972            if (data.rules.length !== 0 || !options.skip_empty) {
1973                groupData.rules.push(data);
1974            }
1975        }, this);
1976
1977        /**
1978         * Modifies the JSON generated from a Group object
1979         * @event changer:groupToJson
1980         * @memberof QueryBuilder
1981         * @param {object} json
1982         * @param {Group} group
1983         * @returns {object}
1984         */
1985        return self.change('groupToJson', groupData, group);
1986
1987    }(this.model.root));
1988
1989    out.valid = valid;
1990
1991    /**
1992     * Modifies the result of the {@link QueryBuilder#getRules} method
1993     * @event changer:getRules
1994     * @memberof QueryBuilder
1995     * @param {object} json
1996     * @returns {object}
1997     */
1998    return this.change('getRules', out);
1999};
2000
2001/**
2002 * Sets rules from object
2003 * @param {object} data
2004 * @param {object} [options]
2005 * @param {boolean} [options.allow_invalid=false] - silent-fail if the data are invalid
2006 * @throws RulesError, UndefinedConditionError
2007 * @fires QueryBuilder.changer:setRules
2008 * @fires QueryBuilder.changer:jsonToRule
2009 * @fires QueryBuilder.changer:jsonToGroup
2010 * @fires QueryBuilder.afterSetRules
2011 */
2012QueryBuilder.prototype.setRules = function(data, options) {
2013    options = $.extend({
2014        allow_invalid: false
2015    }, options);
2016
2017    if ($.isArray(data)) {
2018        data = {
2019            condition: this.settings.default_condition,
2020            rules: data
2021        };
2022    }
2023
2024    if (!data || !data.rules || (data.rules.length === 0 && !this.settings.allow_empty)) {
2025        Utils.error('RulesParse', 'Incorrect data object passed');
2026    }
2027
2028    this.clear();
2029    this.setRoot(false, data.data, this.parseGroupFlags(data));
2030
2031    /**
2032     * Modifies data before the {@link QueryBuilder#setRules} method
2033     * @event changer:setRules
2034     * @memberof QueryBuilder
2035     * @param {object} json
2036     * @param {object} options
2037     * @returns {object}
2038     */
2039    data = this.change('setRules', data, options);
2040
2041    var self = this;
2042
2043    (function add(data, group) {
2044        if (group === null) {
2045            return;
2046        }
2047
2048        if (data.condition === undefined) {
2049            data.condition = self.settings.default_condition;
2050        }
2051        else if (self.settings.conditions.indexOf(data.condition) == -1) {
2052            Utils.error(!options.allow_invalid, 'UndefinedCondition', 'Invalid condition "{0}"', data.condition);
2053            data.condition = self.settings.default_condition;
2054        }
2055
2056        group.condition = data.condition;
2057
2058        data.rules.forEach(function(item) {
2059            var model;
2060
2061            if (item.rules !== undefined) {
2062                if (self.settings.allow_groups !== -1 && self.settings.allow_groups < group.level) {
2063                    Utils.error(!options.allow_invalid, 'RulesParse', 'No more than {0} groups are allowed', self.settings.allow_groups);
2064                    self.reset();
2065                }
2066                else {
2067                    model = self.addGroup(group, false, item.data, self.parseGroupFlags(item));
2068                    if (model === null) {
2069                        return;
2070                    }
2071
2072                    add(item, model);
2073                }
2074            }
2075            else {
2076                if (!item.empty) {
2077                    if (item.id === undefined) {
2078                        Utils.error(!options.allow_invalid, 'RulesParse', 'Missing rule field id');
2079                        item.empty = true;
2080                    }
2081                    if (item.operator === undefined) {
2082                        item.operator = 'equal';
2083                    }
2084                }
2085
2086                model = self.addRule(group, item.data, self.parseRuleFlags(item));
2087                if (model === null) {
2088                    return;
2089                }
2090
2091                if (!item.empty) {
2092                    model.filter = self.getFilterById(item.id, !options.allow_invalid);
2093                }
2094
2095                if (model.filter) {
2096                    model.operator = self.getOperatorByType(item.operator, !options.allow_invalid);
2097
2098                    if (!model.operator) {
2099                        model.operator = self.getOperators(model.filter)[0];
2100                    }
2101                }
2102
2103                if (model.operator && model.operator.nb_inputs !== 0) {
2104                    if (item.value !== undefined) {
2105                        model.value = item.value;
2106                    }
2107                    else if (model.filter.default_value !== undefined) {
2108                        model.value = model.filter.default_value;
2109                    }
2110                }
2111
2112                /**
2113                 * Modifies the Rule object generated from the JSON
2114                 * @event changer:jsonToRule
2115                 * @memberof QueryBuilder
2116                 * @param {Rule} rule
2117                 * @param {object} json
2118                 * @returns {Rule} the same rule
2119                 */
2120                if (self.change('jsonToRule', model, item) != model) {
2121                    Utils.error('RulesParse', 'Plugin tried to change rule reference');
2122                }
2123            }
2124        });
2125
2126        /**
2127         * Modifies the Group object generated from the JSON
2128         * @event changer:jsonToGroup
2129         * @memberof QueryBuilder
2130         * @param {Group} group
2131         * @param {object} json
2132         * @returns {Group} the same group
2133         */
2134        if (self.change('jsonToGroup', group, data) != group) {
2135            Utils.error('RulesParse', 'Plugin tried to change group reference');
2136        }
2137
2138    }(data, this.model.root));
2139
2140    /**
2141     * After the {@link QueryBuilder#setRules} method
2142     * @event afterSetRules
2143     * @memberof QueryBuilder
2144     */
2145    this.trigger('afterSetRules');
2146};
2147
2148
2149/**
2150 * Performs value validation
2151 * @param {Rule} rule
2152 * @param {string|string[]} value
2153 * @returns {array|boolean} true or error array
2154 * @fires QueryBuilder.changer:validateValue
2155 */
2156QueryBuilder.prototype.validateValue = function(rule, value) {
2157    var validation = rule.filter.validation || {};
2158    var result = true;
2159
2160    if (validation.callback) {
2161        result = validation.callback.call(this, value, rule);
2162    }
2163    else {
2164        result = this._validateValue(rule, value);
2165    }
2166
2167    /**
2168     * Modifies the result of the rule validation method
2169     * @event changer:validateValue
2170     * @memberof QueryBuilder
2171     * @param {array|boolean} result - true or an error array
2172     * @param {*} value
2173     * @param {Rule} rule
2174     * @returns {array|boolean}
2175     */
2176    return this.change('validateValue', result, value, rule);
2177};
2178
2179/**
2180 * Default validation function
2181 * @param {Rule} rule
2182 * @param {string|string[]} value
2183 * @returns {array|boolean} true or error array
2184 * @throws ConfigError
2185 * @private
2186 */
2187QueryBuilder.prototype._validateValue = function(rule, value) {
2188    var filter = rule.filter;
2189    var operator = rule.operator;
2190    var validation = filter.validation || {};
2191    var result = true;
2192    var tmp, tempValue;
2193
2194    if (rule.operator.nb_inputs === 1) {
2195        value = [value];
2196    }
2197
2198    for (var i = 0; i < operator.nb_inputs; i++) {
2199        if (!operator.multiple && $.isArray(value[i]) && value[i].length > 1) {
2200            result = ['operator_not_multiple', operator.type, this.translate('operators', operator.type)];
2201            break;
2202        }
2203
2204        switch (filter.input) {
2205            case 'radio':
2206                if (value[i] === undefined || value[i].length === 0) {
2207                    if (!validation.allow_empty_value) {
2208                        result = ['radio_empty'];
2209                    }
2210                    break;
2211                }
2212                break;
2213
2214            case 'checkbox':
2215                if (value[i] === undefined || value[i].length === 0) {
2216                    if (!validation.allow_empty_value) {
2217                        result = ['checkbox_empty'];
2218                    }
2219                    break;
2220                }
2221                break;
2222
2223            case 'select':
2224                if (value[i] === undefined || value[i].length === 0 || (filter.placeholder && value[i] == filter.placeholder_value)) {
2225                    if (!validation.allow_empty_value) {
2226                        result = ['select_empty'];
2227                    }
2228                    break;
2229                }
2230                break;
2231
2232            default:
2233                tempValue = $.isArray(value[i]) ? value[i] : [value[i]];
2234
2235                for (var j = 0; j < tempValue.length; j++) {
2236                    switch (QueryBuilder.types[filter.type]) {
2237                        case 'string':
2238                            if (tempValue[j] === undefined || tempValue[j].length === 0) {
2239                                if (!validation.allow_empty_value) {
2240                                    result = ['string_empty'];
2241                                }
2242                                break;
2243                            }
2244                            if (validation.min !== undefined) {
2245                                if (tempValue[j].length < parseInt(validation.min)) {
2246                                    result = [this.getValidationMessage(validation, 'min', 'string_exceed_min_length'), validation.min];
2247                                    break;
2248                                }
2249                            }
2250                            if (validation.max !== undefined) {
2251                                if (tempValue[j].length > parseInt(validation.max)) {
2252                                    result = [this.getValidationMessage(validation, 'max', 'string_exceed_max_length'), validation.max];
2253                                    break;
2254                                }
2255                            }
2256                            if (validation.format) {
2257                                if (typeof validation.format == 'string') {
2258                                    validation.format = new RegExp(validation.format);
2259                                }
2260                                if (!validation.format.test(tempValue[j])) {
2261                                    result = [this.getValidationMessage(validation, 'format', 'string_invalid_format'), validation.format];
2262                                    break;
2263                                }
2264                            }
2265                            break;
2266
2267                        case 'number':
2268                            if (tempValue[j] === undefined || tempValue[j].length === 0) {
2269                                if (!validation.allow_empty_value) {
2270                                    result = ['number_nan'];
2271                                }
2272                                break;
2273                            }
2274                            if (isNaN(tempValue[j])) {
2275                                result = ['number_nan'];
2276                                break;
2277                            }
2278                            if (filter.type == 'integer') {
2279                                if (parseInt(tempValue[j]) != tempValue[j]) {
2280                                    result = ['number_not_integer'];
2281                                    break;
2282                                }
2283                            }
2284                            else {
2285                                if (parseFloat(tempValue[j]) != tempValue[j]) {
2286                                    result = ['number_not_double'];
2287                                    break;
2288                                }
2289                            }
2290                            if (validation.min !== undefined) {
2291                                if (tempValue[j] < parseFloat(validation.min)) {
2292                                    result = [this.getValidationMessage(validation, 'min', 'number_exceed_min'), validation.min];
2293                                    break;
2294                                }
2295                            }
2296                            if (validation.max !== undefined) {
2297                                if (tempValue[j] > parseFloat(validation.max)) {
2298                                    result = [this.getValidationMessage(validation, 'max', 'number_exceed_max'), validation.max];
2299                                    break;
2300                                }
2301                            }
2302                            if (validation.step !== undefined && validation.step !== 'any') {
2303                                var v = (tempValue[j] / validation.step).toPrecision(14);
2304                                if (parseInt(v) != v) {
2305                                    result = [this.getValidationMessage(validation, 'step', 'number_wrong_step'), validation.step];
2306                                    break;
2307                                }
2308                            }
2309                            break;
2310
2311                        case 'datetime':
2312                            if (tempValue[j] === undefined || tempValue[j].length === 0) {
2313                                if (!validation.allow_empty_value) {
2314                                    result = ['datetime_empty'];
2315                                }
2316                                break;
2317                            }
2318
2319                            // we need MomentJS
2320                            if (validation.format) {
2321                                if (!('moment' in window)) {
2322                                    Utils.error('MissingLibrary', 'MomentJS is required for Date/Time validation. Get it here http://momentjs.com');
2323                                }
2324
2325                                var datetime = moment(tempValue[j], validation.format);
2326                                if (!datetime.isValid()) {
2327                                    result = [this.getValidationMessage(validation, 'format', 'datetime_invalid'), validation.format];
2328                                    break;
2329                                }
2330                                else {
2331                                    if (validation.min) {
2332                                        if (datetime < moment(validation.min, validation.format)) {
2333                                            result = [this.getValidationMessage(validation, 'min', 'datetime_exceed_min'), validation.min];
2334                                            break;
2335                                        }
2336                                    }
2337                                    if (validation.max) {
2338                                        if (datetime > moment(validation.max, validation.format)) {
2339                                            result = [this.getValidationMessage(validation, 'max', 'datetime_exceed_max'), validation.max];
2340                                            break;
2341                                        }
2342                                    }
2343                                }
2344                            }
2345                            break;
2346
2347                        case 'boolean':
2348                            if (tempValue[j] === undefined || tempValue[j].length === 0) {
2349                                if (!validation.allow_empty_value) {
2350                                    result = ['boolean_not_valid'];
2351                                }
2352                                break;
2353                            }
2354                            tmp = ('' + tempValue[j]).trim().toLowerCase();
2355                            if (tmp !== 'true' && tmp !== 'false' && tmp !== '1' && tmp !== '0' && tempValue[j] !== 1 && tempValue[j] !== 0) {
2356                                result = ['boolean_not_valid'];
2357                                break;
2358                            }
2359                    }
2360
2361                    if (result !== true) {
2362                        break;
2363                    }
2364                }
2365        }
2366
2367        if (result !== true) {
2368            break;
2369        }
2370    }
2371
2372    if ((rule.operator.type === 'between' || rule.operator.type === 'not_between') && value.length === 2) {
2373        switch (QueryBuilder.types[filter.type]) {
2374            case 'number':
2375                if (value[0] > value[1]) {
2376                    result = ['number_between_invalid', value[0], value[1]];
2377                }
2378                break;
2379
2380            case 'datetime':
2381                // we need MomentJS
2382                if (validation.format) {
2383                    if (!('moment' in window)) {
2384                        Utils.error('MissingLibrary', 'MomentJS is required for Date/Time validation. Get it here http://momentjs.com');
2385                    }
2386
2387                    if (moment(value[0], validation.format).isAfter(moment(value[1], validation.format))) {
2388                        result = ['datetime_between_invalid', value[0], value[1]];
2389                    }
2390                }
2391                break;
2392        }
2393    }
2394
2395    return result;
2396};
2397
2398/**
2399 * Returns an incremented group ID
2400 * @returns {string}
2401 * @private
2402 */
2403QueryBuilder.prototype.nextGroupId = function() {
2404    return this.status.id + '_group_' + (this.status.group_id++);
2405};
2406
2407/**
2408 * Returns an incremented rule ID
2409 * @returns {string}
2410 * @private
2411 */
2412QueryBuilder.prototype.nextRuleId = function() {
2413    return this.status.id + '_rule_' + (this.status.rule_id++);
2414};
2415
2416/**
2417 * Returns the operators for a filter
2418 * @param {string|object} filter - filter id or filter object
2419 * @returns {object[]}
2420 * @fires QueryBuilder.changer:getOperators
2421 */
2422QueryBuilder.prototype.getOperators = function(filter) {
2423    if (typeof filter == 'string') {
2424        filter = this.getFilterById(filter);
2425    }
2426
2427    var result = [];
2428
2429    for (var i = 0, l = this.operators.length; i < l; i++) {
2430        // filter operators check
2431        if (filter.operators) {
2432            if (filter.operators.indexOf(this.operators[i].type) == -1) {
2433                continue;
2434            }
2435        }
2436        // type check
2437        else if (this.operators[i].apply_to.indexOf(QueryBuilder.types[filter.type]) == -1) {
2438            continue;
2439        }
2440
2441        result.push(this.operators[i]);
2442    }
2443
2444    // keep sort order defined for the filter
2445    if (filter.operators) {
2446        result.sort(function(a, b) {
2447            return filter.operators.indexOf(a.type) - filter.operators.indexOf(b.type);
2448        });
2449    }
2450
2451    /**
2452     * Modifies the operators available for a filter
2453     * @event changer:getOperators
2454     * @memberof QueryBuilder
2455     * @param {QueryBuilder.Operator[]} operators
2456     * @param {QueryBuilder.Filter} filter
2457     * @returns {QueryBuilder.Operator[]}
2458     */
2459    return this.change('getOperators', result, filter);
2460};
2461
2462/**
2463 * Returns a particular filter by its id
2464 * @param {string} id
2465 * @param {boolean} [doThrow=true]
2466 * @returns {object|null}
2467 * @throws UndefinedFilterError
2468 */
2469QueryBuilder.prototype.getFilterById = function(id, doThrow) {
2470    if (id == '-1') {
2471        return null;
2472    }
2473
2474    for (var i = 0, l = this.filters.length; i < l; i++) {
2475        if (this.filters[i].id == id) {
2476            return this.filters[i];
2477        }
2478    }
2479
2480    Utils.error(doThrow !== false, 'UndefinedFilter', 'Undefined filter "{0}"', id);
2481
2482    return null;
2483};
2484
2485/**
2486 * Returns a particular operator by its type
2487 * @param {string} type
2488 * @param {boolean} [doThrow=true]
2489 * @returns {object|null}
2490 * @throws UndefinedOperatorError
2491 */
2492QueryBuilder.prototype.getOperatorByType = function(type, doThrow) {
2493    if (type == '-1') {
2494        return null;
2495    }
2496
2497    for (var i = 0, l = this.operators.length; i < l; i++) {
2498        if (this.operators[i].type == type) {
2499            return this.operators[i];
2500        }
2501    }
2502
2503    Utils.error(doThrow !== false, 'UndefinedOperator', 'Undefined operator "{0}"', type);
2504
2505    return null;
2506};
2507
2508/**
2509 * Returns rule's current input value
2510 * @param {Rule} rule
2511 * @returns {*}
2512 * @fires QueryBuilder.changer:getRuleValue
2513 * @private
2514 */
2515QueryBuilder.prototype.getRuleInputValue = function(rule) {
2516    var filter = rule.filter;
2517    var operator = rule.operator;
2518    var value = [];
2519
2520    if (filter.valueGetter) {
2521        value = filter.valueGetter.call(this, rule);
2522    }
2523    else {
2524        var $value = rule.$el.find(QueryBuilder.selectors.value_container);
2525
2526        for (var i = 0; i < operator.nb_inputs; i++) {
2527            var name = Utils.escapeElementId(rule.id + '_value_' + i);
2528            var tmp;
2529
2530            switch (filter.input) {
2531                case 'radio':
2532                    value.push($value.find('[name=' + name + ']:checked').val());
2533                    break;
2534
2535                case 'checkbox':
2536                    tmp = [];
2537                    $value.find('[name=' + name + ']:checked').each(function() {
2538                        tmp.push($(this).val());
2539                    });
2540                    value.push(tmp);
2541                    break;
2542
2543                case 'select':
2544                    if (filter.multiple) {
2545                        tmp = [];
2546                        $value.find('[name=' + name + '] option:selected').each(function() {
2547                            tmp.push($(this).val());
2548                        });
2549                        value.push(tmp);
2550                    }
2551                    else {
2552                        value.push($value.find('[name=' + name + '] option:selected').val());
2553                    }
2554                    break;
2555
2556                default:
2557                    value.push($value.find('[name=' + name + ']').val());
2558            }
2559        }
2560
2561        value = value.map(function(val) {
2562            if (operator.multiple && filter.value_separator && typeof val == 'string') {
2563                val = val.split(filter.value_separator);
2564            }
2565
2566            if ($.isArray(val)) {
2567                return val.map(function(subval) {
2568                    return Utils.changeType(subval, filter.type);
2569                });
2570            }
2571            else {
2572                return Utils.changeType(val, filter.type);
2573            }
2574        });
2575
2576        if (operator.nb_inputs === 1) {
2577            value = value[0];
2578        }
2579
2580        // @deprecated
2581        if (filter.valueParser) {
2582            value = filter.valueParser.call(this, rule, value);
2583        }
2584    }
2585
2586    /**
2587     * Modifies the rule's value grabbed from the DOM
2588     * @event changer:getRuleValue
2589     * @memberof QueryBuilder
2590     * @param {*} value
2591     * @param {Rule} rule
2592     * @returns {*}
2593     */
2594    return this.change('getRuleValue', value, rule);
2595};
2596
2597/**
2598 * Sets the value of a rule's input
2599 * @param {Rule} rule
2600 * @param {*} value
2601 * @private
2602 */
2603QueryBuilder.prototype.setRuleInputValue = function(rule, value) {
2604    var filter = rule.filter;
2605    var operator = rule.operator;
2606
2607    if (!filter || !operator) {
2608        return;
2609    }
2610
2611    rule._updating_input = true;
2612
2613    if (filter.valueSetter) {
2614        filter.valueSetter.call(this, rule, value);
2615    }
2616    else {
2617        var $value = rule.$el.find(QueryBuilder.selectors.value_container);
2618
2619        if (operator.nb_inputs == 1) {
2620            value = [value];
2621        }
2622
2623        for (var i = 0; i < operator.nb_inputs; i++) {
2624            var name = Utils.escapeElementId(rule.id + '_value_' + i);
2625
2626            switch (filter.input) {
2627                case 'radio':
2628                    $value.find('[name=' + name + '][value="' + value[i] + '"]').prop('checked', true).trigger('change');
2629                    break;
2630
2631                case 'checkbox':
2632                    if (!$.isArray(value[i])) {
2633                        value[i] = [value[i]];
2634                    }
2635                    value[i].forEach(function(value) {
2636                        $value.find('[name=' + name + '][value="' + value + '"]').prop('checked', true).trigger('change');
2637                    });
2638                    break;
2639
2640                default:
2641                    if (operator.multiple && filter.value_separator && $.isArray(value[i])) {
2642                        value[i] = value[i].join(filter.value_separator);
2643                    }
2644                    $value.find('[name=' + name + ']').val(value[i]).trigger('change');
2645                    break;
2646            }
2647        }
2648    }
2649
2650    rule._updating_input = false;
2651};
2652
2653/**
2654 * Parses rule flags
2655 * @param {object} rule
2656 * @returns {object}
2657 * @fires QueryBuilder.changer:parseRuleFlags
2658 * @private
2659 */
2660QueryBuilder.prototype.parseRuleFlags = function(rule) {
2661    var flags = $.extend({}, this.settings.default_rule_flags);
2662
2663    if (rule.readonly) {
2664        $.extend(flags, {
2665            filter_readonly: true,
2666            operator_readonly: true,
2667            value_readonly: true,
2668            no_delete: true
2669        });
2670    }
2671
2672    if (rule.flags) {
2673        $.extend(flags, rule.flags);
2674    }
2675
2676    /**
2677     * Modifies the consolidated rule's flags
2678     * @event changer:parseRuleFlags
2679     * @memberof QueryBuilder
2680     * @param {object} flags
2681     * @param {object} rule - <b>not</b> a Rule object
2682     * @returns {object}
2683     */
2684    return this.change('parseRuleFlags', flags, rule);
2685};
2686
2687/**
2688 * Gets a copy of flags of a rule
2689 * @param {object} flags
2690 * @param {boolean} [all=false] - return all flags or only changes from default flags
2691 * @returns {object}
2692 * @private
2693 */
2694QueryBuilder.prototype.getRuleFlags = function(flags, all) {
2695    if (all) {
2696        return $.extend({}, flags);
2697    }
2698    else {
2699        var ret = {};
2700        $.each(this.settings.default_rule_flags, function(key, value) {
2701            if (flags[key] !== value) {
2702                ret[key] = flags[key];
2703            }
2704        });
2705        return ret;
2706    }
2707};
2708
2709/**
2710 * Parses group flags
2711 * @param {object} group
2712 * @returns {object}
2713 * @fires QueryBuilder.changer:parseGroupFlags
2714 * @private
2715 */
2716QueryBuilder.prototype.parseGroupFlags = function(group) {
2717    var flags = $.extend({}, this.settings.default_group_flags);
2718
2719    if (group.readonly) {
2720        $.extend(flags, {
2721            condition_readonly: true,
2722            no_add_rule: true,
2723            no_add_group: true,
2724            no_delete: true
2725        });
2726    }
2727
2728    if (group.flags) {
2729        $.extend(flags, group.flags);
2730    }
2731
2732    /**
2733     * Modifies the consolidated group's flags
2734     * @event changer:parseGroupFlags
2735     * @memberof QueryBuilder
2736     * @param {object} flags
2737     * @param {object} group - <b>not</b> a Group object
2738     * @returns {object}
2739     */
2740    return this.change('parseGroupFlags', flags, group);
2741};
2742
2743/**
2744 * Gets a copy of flags of a group
2745 * @param {object} flags
2746 * @param {boolean} [all=false] - return all flags or only changes from default flags
2747 * @returns {object}
2748 * @private
2749 */
2750QueryBuilder.prototype.getGroupFlags = function(flags, all) {
2751    if (all) {
2752        return $.extend({}, flags);
2753    }
2754    else {
2755        var ret = {};
2756        $.each(this.settings.default_group_flags, function(key, value) {
2757            if (flags[key] !== value) {
2758                ret[key] = flags[key];
2759            }
2760        });
2761        return ret;
2762    }
2763};
2764
2765/**
2766 * Translate a label either by looking in the `lang` object or in itself if it's an object where keys are language codes
2767 * @param {string} [category]
2768 * @param {string|object} key
2769 * @returns {string}
2770 * @fires QueryBuilder.changer:translate
2771 */
2772QueryBuilder.prototype.translate = function(category, key) {
2773    if (!key) {
2774        key = category;
2775        category = undefined;
2776    }
2777
2778    var translation;
2779    if (typeof key === 'object') {
2780        translation = key[this.settings.lang_code] || key['en'];
2781    }
2782    else {
2783        translation = (category ? this.lang[category] : this.lang)[