QueryBuilder.prototype.destroy = function (){ 
this.trigger('beforeDestroy'); 
if (this.status.generated_id) { 
this.$el.removeAttr('id'); 
} 
_AN_Call_clear('clear', this); 
this.model = null ; 
this.$el.off('.queryBuilder').removeClass('query-builder').removeData('queryBuilder'); 
delete this.$el[0].queryBuilder; 
} 
; 
QueryBuilder.prototype.reset = function (){ 
var e = this.trigger('beforeReset'); 
if (e.isDefaultPrevented()) { 
return ; 
} 
this.status.group_id = 1; 
this.status.rule_id = 0; 
this.model.root.empty(); 
this.model.root.data = undefined; 
this.model.root.flags = $.extend({ 
}
, this.settings.default_group_flags); 
this.model.root.condition = this.settings.default_condition; 
_AN_Call_addrule('addRule', this, this.model.root); 
this.trigger('afterReset'); 
this.trigger('rulesChanged'); 
} 
; 
QueryBuilder.prototype.clear = function (){ 
var e = this.trigger('beforeClear'); 
if (e.isDefaultPrevented()) { 
return ; 
} 
this.status.group_id = 0; 
this.status.rule_id = 0; 
if (this.model.root) { 
this.model.root.drop(); 
this.model.root = null ; 
} 
this.trigger('afterClear'); 
this.trigger('rulesChanged'); 
} 
; 
QueryBuilder.prototype.setOptions = function (options){ 
$.each(options, function (opt, value){ 
if (QueryBuilder.modifiable_options.indexOf(opt) !== -1) { 
this.settings[opt] = value; 
} 
} 
.bind(this)); 
} 
; 
QueryBuilder.prototype.getModel = function (target){ 
if (!target) { 
return this.model.root; 
} 
 else if (target instanceof Node) { 
return target; 
} 
 else { 
return $(target).data('queryBuilderModel'); 
} 
} 
; 
QueryBuilder.prototype.validate = function (options){ 
options = $.extend({ 
skip_empty: false }
, options); 
this.clearErrors(); 
var self = this; 
var valid = (function parse(group){ 
var done = 0; 
var errors = 0; 
group.each(function (rule){ 
if (!rule.filter && options.skip_empty) { 
return ; 
} 
if (!rule.filter) { 
self.triggerValidationError(rule, 'no_filter', null ); 
errors++ ; 
return ; 
} 
if (!rule.operator) { 
self.triggerValidationError(rule, 'no_operator', null ); 
errors++ ; 
return ; 
} 
if (rule.operator.nb_inputs !== 0) { 
var valid = self.validateValue(rule, rule.value); 
if (valid !== true ) { 
self.triggerValidationError(rule, valid, rule.value); 
errors++ ; 
return ; 
} 
} 
done++ ; 
} 
, function (group){ 
var res = parse(group); 
if (res === true ) { 
done++ ; 
} 
 else if (res === false ) { 
errors++ ; 
} 
} 
); 
if (errors > 0) { 
return false ; 
} 
 else if (done === 0 && !group.isRoot() && options.skip_empty) { 
return null ; 
} 
 else if (done === 0 && (!self.settings.allow_empty || !group.isRoot())) { 
self.triggerValidationError(group, 'empty_group', null ); 
return false ; 
} 
return true ; 
} 
(this.model.root)); 
return this.change('validate', valid); 
} 
; 
QueryBuilder.prototype.getRules = function (options){ 
options = $.extend({ 
get_flags: false ,
allow_invalid: false ,
skip_empty: false }
, options); 
var valid = this.validate(options); 
if (!valid && !options.allow_invalid) { 
return null ; 
} 
var self = this; 
var out = (function parse(group){ 
var groupData = { 
condition: group.condition,
rules: [] }
; 
if (group.data) { 
groupData.data = $.extendext(true , 'replace', { 
}
, group.data); 
} 
if (options.get_flags) { 
var flags = self.getGroupFlags(group.flags, options.get_flags === 'all'); 
if (!$.isEmptyObject(flags)) { 
groupData.flags = flags; 
} 
} 
group.each(function (rule){ 
if (!rule.filter && options.skip_empty) { 
return ; 
} 
var value = null ; 
if (!rule.operator || rule.operator.nb_inputs !== 0) { 
value = rule.value; 
} 
var ruleData = { 
id: rule.filter? rule.filter.id: null ,
field: rule.filter? rule.filter.field: null ,
type: rule.filter? rule.filter.type: null ,
input: rule.filter? rule.filter.input: null ,
operator: rule.operator? rule.operator.type: null ,
value: value}
; 
if (rule.filter && rule.filter.data || rule.data) { 
ruleData.data = $.extendext(true , 'replace', { 
}
, rule.filter? rule.filter.data: { 
}
, rule.data); 
} 
if (options.get_flags) { 
var flags = self.getRuleFlags(rule.flags, options.get_flags === 'all'); 
if (!$.isEmptyObject(flags)) { 
ruleData.flags = flags; 
} 
} 
groupData.rules.push(self.change('ruleToJson', ruleData, rule)); 
} 
, function (model){ 
var data = parse(model); 
if (_AN_Read_length('length', data.rules) !== 0 || !options.skip_empty) { 
groupData.rules.push(data); 
} 
} 
, this); 
return self.change('groupToJson', groupData, group); 
} 
(this.model.root)); 
out.valid = valid; 
return this.change('getRules', out); 
} 
; 
QueryBuilder.prototype.setRules = function (data, options){ 
options = $.extend({ 
allow_invalid: false }
, options); 
if ($.isArray(data)) { 
data = { 
condition: this.settings.default_condition,
rules: data}
; 
} 
if (!data || !data.rules || (_AN_Read_length('length', data.rules) === 0 && !this.settings.allow_empty)) { 
Utils.error('RulesParse', 'Incorrect data object passed'); 
} 
_AN_Call_clear('clear', this); 
this.setRoot(false , data.data, this.parseGroupFlags(data)); 
data = this.change('setRules', data, options); 
var self = this; 
(function add(data, group){ 
if (group === null ) { 
return ; 
} 
if (data.condition === undefined) { 
data.condition = self.settings.default_condition; 
} 
 else if (self.settings.conditions.indexOf(data.condition) == -1) { 
Utils.error(!options.allow_invalid, 'UndefinedCondition', 'Invalid condition "{0}"', data.condition); 
data.condition = self.settings.default_condition; 
} 
group.condition = data.condition; 
data.rules.forEach(function (item){ 
var model; 
if (item.rules !== undefined) { 
if (self.settings.allow_groups !== -1 && self.settings.allow_groups < group.level) { 
Utils.error(!options.allow_invalid, 'RulesParse', 'No more than {0} groups are allowed', self.settings.allow_groups); 
self.reset(); 
} 
 else { 
model = self.addGroup(group, false , item.data, self.parseGroupFlags(item)); 
if (model === null ) { 
return ; 
} 
add(item, model); 
} 
} 
 else { 
if (!item.empty) { 
if (item.id === undefined) { 
Utils.error(!options.allow_invalid, 'RulesParse', 'Missing rule field id'); 
item.empty = true ; 
} 
if (item.operator === undefined) { 
item.operator = 'equal'; 
} 
} 
model = _AN_Call_addrule('addRule', self, group, item.data, self.parseRuleFlags(item)); 
if (model === null ) { 
return ; 
} 
if (!item.empty) { 
_AN_Write_filter('filter', model, false , self.getFilterById(item.id, !options.allow_invalid)); 
} 
if (model.filter) { 
model.operator = self.getOperatorByType(item.operator, !options.allow_invalid); 
if (!model.operator) { 
model.operator = self.getOperators(model.filter)[0]; 
} 
} 
if (model.operator && model.operator.nb_inputs !== 0) { 
if (item.value !== undefined) { 
model.value = item.value; 
} 
 else if (model.filter.default_value !== undefined) { 
model.value = model.filter.default_value; 
} 
} 
if (self.change('jsonToRule', model, item) != model) { 
Utils.error('RulesParse', 'Plugin tried to change rule reference'); 
} 
} 
} 
); 
if (self.change('jsonToGroup', group, data) != group) { 
Utils.error('RulesParse', 'Plugin tried to change group reference'); 
} 
} 
(data, this.model.root)); 
this.trigger('afterSetRules'); 
} 
;