676 lines
20 KiB
JavaScript
676 lines
20 KiB
JavaScript
/*
|
|
* jqFilter jQuery jqGrid filter addon.
|
|
* Copyright (c) 2011, Tony Tomov, tony@trirand.com
|
|
* Dual licensed under the MIT and GPL licenses
|
|
* http://www.opensource.org/licenses/mit-license.php
|
|
* http://www.gnu.org/licenses/gpl-2.0.html
|
|
*
|
|
* The work is inspired from this Stefan Pirvu
|
|
* http://www.codeproject.com/KB/scripting/json-filtering.aspx
|
|
*
|
|
* The filter uses JSON entities to hold filter rules and groups. Here is an example of a filter:
|
|
|
|
{ "groupOp": "AND",
|
|
"groups" : [
|
|
{ "groupOp": "OR",
|
|
"rules": [
|
|
{ "field": "name", "op": "eq", "data": "England" },
|
|
{ "field": "id", "op": "le", "data": "5"}
|
|
]
|
|
}
|
|
],
|
|
"rules": [
|
|
{ "field": "name", "op": "eq", "data": "Romania" },
|
|
{ "field": "id", "op": "le", "data": "1"}
|
|
]
|
|
}
|
|
*/
|
|
/*global jQuery, $ */
|
|
|
|
(function ($) {
|
|
|
|
$.fn.jqFilter = function( arg ) {
|
|
if (typeof arg === 'string') {
|
|
|
|
var fn = $.fn.jqFilter[arg];
|
|
if (!fn) {
|
|
throw ("jqFilter - No such method: " + arg);
|
|
}
|
|
var args = $.makeArray(arguments).slice(1);
|
|
return fn.apply(this,args);
|
|
}
|
|
|
|
var p = $.extend(true,{
|
|
filter: null,
|
|
columns: [],
|
|
onChange : null,
|
|
checkValues : null,
|
|
error: false,
|
|
errmsg : "",
|
|
errorcheck : true,
|
|
showQuery : true,
|
|
sopt : null,
|
|
ops : [
|
|
{"name": "eq", "description": "equal", "operator":"="},
|
|
{"name": "ne", "description": "not equal", "operator":"<>"},
|
|
{"name": "lt", "description": "less", "operator":"<"},
|
|
{"name": "le", "description": "less or equal","operator":"<="},
|
|
{"name": "gt", "description": "greater", "operator":">"},
|
|
{"name": "ge", "description": "greater or equal", "operator":">="},
|
|
{"name": "bw", "description": "begins with", "operator":"LIKE"},
|
|
{"name": "bn", "description": "does not begin with", "operator":"NOT LIKE"},
|
|
{"name": "in", "description": "in", "operator":"IN"},
|
|
{"name": "ni", "description": "not in", "operator":"NOT IN"},
|
|
{"name": "ew", "description": "ends with", "operator":"LIKE"},
|
|
{"name": "en", "description": "does not end with", "operator":"NOT LIKE"},
|
|
{"name": "cn", "description": "contains", "operator":"LIKE"},
|
|
{"name": "nc", "description": "does not contain", "operator":"NOT LIKE"},
|
|
{"name": "nu", "description": "is null", "operator":"IS NULL"},
|
|
{"name": "nn", "description": "is not null", "operator":"IS NOT NULL"}
|
|
],
|
|
numopts : ['eq','ne', 'lt', 'le', 'gt', 'ge', 'nu', 'nn', 'in', 'ni'],
|
|
stropts : ['eq', 'ne', 'bw', 'bn', 'ew', 'en', 'cn', 'nc', 'nu', 'nn', 'in', 'ni'],
|
|
_gridsopt : [], // grid translated strings, do not tuch
|
|
groupOps : ["AND", "OR"],
|
|
groupButton : true
|
|
}, arg || {});
|
|
return this.each( function() {
|
|
if (this.filter) {return;}
|
|
this.p = p;
|
|
// setup filter in case if they is not defined
|
|
if (this.p.filter === null || this.p.filter === undefined) {
|
|
this.p.filter = {
|
|
groupOp: this.p.groupOps[0],
|
|
rules: [],
|
|
groups: []
|
|
};
|
|
}
|
|
var i, len = this.p.columns.length, cl;
|
|
|
|
// translating the options
|
|
if(this.p._gridsopt.length) {
|
|
// ['eq','ne','lt','le','gt','ge','bw','bn','in','ni','ew','en','cn','nc']
|
|
for(i=0;i<this.p._gridsopt.length;i++) {
|
|
this.p.ops[i].description = this.p._gridsopt[i];
|
|
}
|
|
}
|
|
this.p.initFilter = $.extend(true,{},this.p.filter);
|
|
|
|
// set default values for the columns if they are not set
|
|
if( !len ) {return;}
|
|
for(i=0; i < len; i++) {
|
|
cl = this.p.columns[i];
|
|
if( cl.stype ) {
|
|
// grid compatibility
|
|
cl.inputtype = cl.stype;
|
|
} else if(!cl.inputtype) {
|
|
cl.inputtype = 'text';
|
|
}
|
|
if( cl.sorttype ) {
|
|
// grid compatibility
|
|
cl.searchtype = cl.sorttype;
|
|
} else if (!cl.searchtype) {
|
|
cl.searchtype = 'string';
|
|
}
|
|
if(cl.hidden === undefined) {
|
|
// jqGrid compatibility
|
|
cl.hidden = false;
|
|
}
|
|
if(!cl.label) {
|
|
cl.label = cl.name;
|
|
}
|
|
if(!cl.hasOwnProperty('searchoptions')) {
|
|
cl.searchoptions = {};
|
|
}
|
|
if(!cl.hasOwnProperty('searchrules')) {
|
|
cl.searchrules = {};
|
|
}
|
|
|
|
}
|
|
if(this.p.showQuery) {
|
|
$(this).append("<table class='queryresult ui-widget ui-widget-content' style='display:block;max-width:440px;border:0px none;'><tbody><tr><td class='query'></td></tr></tbody></table>");
|
|
}
|
|
/*
|
|
*Perform checking.
|
|
*
|
|
*/
|
|
var checkData = function(val, colModelItem) {
|
|
var ret = [true,""];
|
|
if($.isFunction(colModelItem.searchrules)) {
|
|
ret = colModelItem.searchrules(val, colModelItem);
|
|
} else if($.jgrid && $.jgrid.checkValues) {
|
|
try {
|
|
ret = $.jgrid.checkValues(val, -1, null, colModelItem.searchrules, colModelItem.label);
|
|
} catch (e) {}
|
|
}
|
|
if(ret && ret.length && ret[0] === false) {
|
|
p.error = !ret[0];
|
|
p.errmsg = ret[1];
|
|
}
|
|
},
|
|
randId = function() {
|
|
return Math.floor(Math.random()*10000).toString();
|
|
};
|
|
|
|
this.onchange = function ( ){
|
|
// clear any error
|
|
this.p.error = false;
|
|
this.p.errmsg="";
|
|
return $.isFunction(this.p.onChange) ? this.p.onChange.call( this, this.p ) : false;
|
|
};
|
|
/*
|
|
* Redrow the filter every time when new field is added/deleted
|
|
* and field is changed
|
|
*/
|
|
this.reDraw = function() {
|
|
$("table.group:first",this).remove();
|
|
var t = this.createTableForGroup(p.filter, null);
|
|
$(this).append(t);
|
|
};
|
|
/*
|
|
* Creates a grouping data for the filter
|
|
* @param group - object
|
|
* @param parentgroup - object
|
|
*/
|
|
this.createTableForGroup = function(group, parentgroup) {
|
|
var that = this, i;
|
|
|
|
// this table will hold all the group (tables) and rules (rows)
|
|
var table = $("<table class='group ui-widget ui-widget-content' style='border:0px none;'><tbody>");
|
|
// create error message row
|
|
if(parentgroup === null) {
|
|
$(table).append("<tr class='error' style='display:none;'><th colspan='5' class='ui-state-error' align='left'></th></tr>");
|
|
}
|
|
|
|
var tr = $("<tr></tr>");
|
|
$(table).append(tr);
|
|
// this header will hold the group operator type and group action buttons for
|
|
// creating subgroup "+ {}", creating rule "+" or deleting the group "-"
|
|
var th = $("<th colspan='5' align='left'></th>");
|
|
tr.append(th);
|
|
|
|
// dropdown for: choosing group operator type
|
|
var groupOpSelect = $("<select class='opsel'></select>");
|
|
th.append(groupOpSelect);
|
|
// populate dropdown with all posible group operators: or, and
|
|
var str= "", selected;
|
|
for (i = 0; i < p.groupOps.length; i++) {
|
|
selected = group.groupOp === that.p.groupOps[i] ? " selected='selected'" :"";
|
|
str += "<option value='"+that.p.groupOps[i]+"'" + selected+">"+that.p.groupOps[i]+"</option>";
|
|
}
|
|
|
|
groupOpSelect
|
|
.append(str)
|
|
.bind('change',function() {
|
|
group.groupOp = $(groupOpSelect).val();
|
|
that.onchange(); // signals that the filter has changed
|
|
});
|
|
|
|
// button for adding a new subgroup
|
|
var inputAddSubgroup;
|
|
if(this.p.groupButton) {
|
|
inputAddSubgroup = $("<input type='button' value='+ {}' title='Add subgroup' class='add-group'/>");
|
|
inputAddSubgroup.bind('click',function() {
|
|
if (group.groups === undefined ) {
|
|
group.groups = [];
|
|
}
|
|
|
|
group.groups.push({
|
|
groupOp: p.groupOps[0],
|
|
rules: [],
|
|
groups: []
|
|
}); // adding a new group
|
|
|
|
that.reDraw(); // the html has changed, force reDraw
|
|
|
|
that.onchange(); // signals that the filter has changed
|
|
return false;
|
|
});
|
|
} else {
|
|
inputAddSubgroup = "<span></span>";
|
|
}
|
|
th.append(inputAddSubgroup);
|
|
|
|
// button for adding a new rule
|
|
var inputAddRule = $("<input type='button' value='+' title='Add rule' class='add-rule'/>"), cm;
|
|
inputAddRule.bind('click',function() {
|
|
//if(!group) { group = {};}
|
|
if (group.rules === undefined) {
|
|
group.rules = [];
|
|
}
|
|
for (i = 0; i < that.p.columns.length; i++) {
|
|
// but show only serchable and serchhidden = true fields
|
|
var searchable = (typeof that.p.columns[i].search === 'undefined') ? true: that.p.columns[i].search ,
|
|
hidden = (that.p.columns[i].hidden === true),
|
|
ignoreHiding = (that.p.columns[i].searchoptions.searchhidden === true);
|
|
if ((ignoreHiding && searchable) || (searchable && !hidden)) {
|
|
cm = that.p.columns[i];
|
|
break;
|
|
}
|
|
}
|
|
var opr;
|
|
if( cm.searchoptions.sopt ) {opr = cm.searchoptions.sopt;}
|
|
else if(that.p.sopt) { opr= that.p.sopt; }
|
|
else if (cm.searchtype === 'string') {opr = that.p.stropts;}
|
|
else {opr = that.p.numopts;}
|
|
|
|
group.rules.push({
|
|
field: cm.name,
|
|
op: opr[0],
|
|
data: ""
|
|
}); // adding a new rule
|
|
|
|
that.reDraw(); // the html has changed, force reDraw
|
|
// for the moment no change have been made to the rule, so
|
|
// this will not trigger onchange event
|
|
return false;
|
|
});
|
|
th.append(inputAddRule);
|
|
|
|
// button for delete the group
|
|
if (parentgroup !== null) { // ignore the first group
|
|
var inputDeleteGroup = $("<input type='button' value='-' title='Delete group' class='delete-group'/>");
|
|
th.append(inputDeleteGroup);
|
|
inputDeleteGroup.bind('click',function() {
|
|
// remove group from parent
|
|
for (i = 0; i < parentgroup.groups.length; i++) {
|
|
if (parentgroup.groups[i] === group) {
|
|
parentgroup.groups.splice(i, 1);
|
|
break;
|
|
}
|
|
}
|
|
|
|
that.reDraw(); // the html has changed, force reDraw
|
|
|
|
that.onchange(); // signals that the filter has changed
|
|
return false;
|
|
});
|
|
}
|
|
|
|
// append subgroup rows
|
|
if (group.groups !== undefined) {
|
|
for (i = 0; i < group.groups.length; i++) {
|
|
var trHolderForSubgroup = $("<tr></tr>");
|
|
table.append(trHolderForSubgroup);
|
|
|
|
var tdFirstHolderForSubgroup = $("<td class='first'></td>");
|
|
trHolderForSubgroup.append(tdFirstHolderForSubgroup);
|
|
|
|
var tdMainHolderForSubgroup = $("<td colspan='4'></td>");
|
|
tdMainHolderForSubgroup.append(this.createTableForGroup(group.groups[i], group));
|
|
trHolderForSubgroup.append(tdMainHolderForSubgroup);
|
|
}
|
|
}
|
|
if(group.groupOp === undefined) {
|
|
group.groupOp = that.p.groupOps[0];
|
|
}
|
|
|
|
// append rules rows
|
|
if (group.rules !== undefined) {
|
|
for (i = 0; i < group.rules.length; i++) {
|
|
table.append(
|
|
this.createTableRowForRule(group.rules[i], group)
|
|
);
|
|
}
|
|
}
|
|
|
|
return table;
|
|
};
|
|
/*
|
|
* Create the rule data for the filter
|
|
*/
|
|
this.createTableRowForRule = function(rule, group) {
|
|
// save current entity in a variable so that it could
|
|
// be referenced in anonimous method calls
|
|
|
|
var that=this, tr = $("<tr></tr>"),
|
|
//document.createElement("tr"),
|
|
|
|
// first column used for padding
|
|
//tdFirstHolderForRule = document.createElement("td"),
|
|
i, op, trpar, cm, str="", selected;
|
|
//tdFirstHolderForRule.setAttribute("class", "first");
|
|
tr.append("<td class='first'></td>");
|
|
|
|
|
|
// create field container
|
|
var ruleFieldTd = $("<td class='columns'></td>");
|
|
tr.append(ruleFieldTd);
|
|
|
|
|
|
// dropdown for: choosing field
|
|
var ruleFieldSelect = $("<select></select>");
|
|
ruleFieldTd.append(ruleFieldSelect);
|
|
ruleFieldSelect.bind('change',function() {
|
|
rule.field = $(ruleFieldSelect).val();
|
|
|
|
trpar = $(this).parents("tr:first");
|
|
for (i=0;i<that.p.columns.length;i++) {
|
|
if(that.p.columns[i].name === rule.field) {
|
|
cm = that.p.columns[i];
|
|
break;
|
|
}
|
|
}
|
|
if(!cm) { return;}
|
|
cm.searchoptions.id = randId();
|
|
var elm = $.jgrid.createEl(cm.inputtype,cm.searchoptions, "", true, that.p.ajaxSelectOptions, true);
|
|
$(elm).addClass("input-elm");
|
|
//that.createElement(rule, "");
|
|
|
|
if( cm.searchoptions.sopt ) {op = cm.searchoptions.sopt;}
|
|
else if(that.p.sopt) { op= that.p.sopt; }
|
|
else if (cm.searchtype === 'string') {op = that.p.stropts;}
|
|
else {op = that.p.numopts;}
|
|
// operators
|
|
var s ="",so="";
|
|
for ( i = 0; i < that.p.ops.length; i++) {
|
|
if($.inArray(that.p.ops[i].name, op) !== -1) {
|
|
so = rule.op === that.p.ops[i].name ? " selected=selected" : "";
|
|
s += "<option value='"+that.p.ops[i].name+"'"+ so+">"+that.p.ops[i].description+"</option>";
|
|
}
|
|
}
|
|
$(".selectopts",trpar).empty().append( s );
|
|
|
|
// data
|
|
$(".data",trpar).empty().append( elm );
|
|
$(".input-elm",trpar).bind('change',function() {
|
|
rule.data = $(this).val();
|
|
if($.isArray(rule.data)) { rule.data = rule.data.join(","); }
|
|
that.onchange(); // signals that the filter has changed
|
|
});
|
|
setTimeout(function(){ //IE, Opera, Chrome
|
|
rule.data = $(elm).val();
|
|
that.onchange(); // signals that the filter has changed
|
|
}, 0);
|
|
});
|
|
|
|
// populate drop down with user provided column definitions
|
|
var j=0;
|
|
for (i = 0; i < that.p.columns.length; i++) {
|
|
// but show only serchable and serchhidden = true fields
|
|
var searchable = (typeof that.p.columns[i].search === 'undefined') ? true: that.p.columns[i].search ,
|
|
hidden = (that.p.columns[i].hidden === true),
|
|
ignoreHiding = (that.p.columns[i].searchoptions.searchhidden === true);
|
|
if ((ignoreHiding && searchable) || (searchable && !hidden)) {
|
|
selected = "";
|
|
if(rule.field === that.p.columns[i].name) {
|
|
selected = " selected='selected'";
|
|
j=i;
|
|
}
|
|
str += "<option value='"+that.p.columns[i].name+"'" +selected+">"+that.p.columns[i].label+"</option>";
|
|
}
|
|
}
|
|
ruleFieldSelect.append( str );
|
|
|
|
|
|
// create operator container
|
|
var ruleOperatorTd = $("<td class='operators'></td>");
|
|
tr.append(ruleOperatorTd);
|
|
cm = p.columns[j];
|
|
// create it here so it can be referentiated in the onchange event
|
|
//var RD = that.createElement(rule, rule.data);
|
|
cm.searchoptions.id = randId();
|
|
var ruleDataInput = $.jgrid.createEl(cm.inputtype,cm.searchoptions, rule.data, true, that.p.ajaxSelectOptions, true);
|
|
|
|
// dropdown for: choosing operator
|
|
var ruleOperatorSelect = $("<select class='selectopts'></select>");
|
|
ruleOperatorTd.append(ruleOperatorSelect);
|
|
ruleOperatorSelect.bind('change',function() {
|
|
rule.op = $(ruleOperatorSelect).val();
|
|
trpar = $(this).parents("tr:first");
|
|
var rd = $(".input-elm",trpar)[0];
|
|
if (rule.op === "nu" || rule.op === "nn") { // disable for operator "is null" and "is not null"
|
|
rule.data = "";
|
|
rd.value = "";
|
|
rd.setAttribute("readonly", "true");
|
|
rd.setAttribute("disabled", "true");
|
|
} else {
|
|
rd.removeAttribute("readonly");
|
|
rd.removeAttribute("disabled");
|
|
}
|
|
|
|
that.onchange(); // signals that the filter has changed
|
|
});
|
|
|
|
// populate drop down with all available operators
|
|
if( cm.searchoptions.sopt ) {op = cm.searchoptions.sopt;}
|
|
else if(that.p.sopt) { op= that.p.sopt; }
|
|
else if (cm.searchtype === 'string') {op = p.stropts;}
|
|
else {op = that.p.numopts;}
|
|
str="";
|
|
for ( i = 0; i < that.p.ops.length; i++) {
|
|
if($.inArray(that.p.ops[i].name, op) !== -1) {
|
|
selected = rule.op === that.p.ops[i].name ? " selected='selected'" : "";
|
|
str += "<option value='"+that.p.ops[i].name+"'"+selected+">"+that.p.ops[i].description+"</option>";
|
|
}
|
|
}
|
|
ruleOperatorSelect.append( str );
|
|
// create data container
|
|
var ruleDataTd = $("<td class='data'></td>");
|
|
tr.append(ruleDataTd);
|
|
|
|
// textbox for: data
|
|
// is created previously
|
|
//ruleDataInput.setAttribute("type", "text");
|
|
ruleDataTd.append(ruleDataInput);
|
|
|
|
$(ruleDataInput)
|
|
.addClass("input-elm")
|
|
.bind('change', function() {
|
|
rule.data = $(this).val();
|
|
if($.isArray(rule.data)) { rule.data = rule.data.join(","); }
|
|
|
|
that.onchange(); // signals that the filter has changed
|
|
});
|
|
|
|
// create action container
|
|
var ruleDeleteTd = $("<td></td>");
|
|
tr.append(ruleDeleteTd);
|
|
|
|
// create button for: delete rule
|
|
var ruleDeleteInput = $("<input type='button' value='-' title='Delete rule' class='delete-rule'/>");
|
|
ruleDeleteTd.append(ruleDeleteInput);
|
|
//$(ruleDeleteInput).html("").height(20).width(30).button({icons: { primary: "ui-icon-minus", text:false}});
|
|
ruleDeleteInput.bind('click',function() {
|
|
// remove rule from group
|
|
for (i = 0; i < group.rules.length; i++) {
|
|
if (group.rules[i] === rule) {
|
|
group.rules.splice(i, 1);
|
|
break;
|
|
}
|
|
}
|
|
|
|
that.reDraw(); // the html has changed, force reDraw
|
|
|
|
that.onchange(); // signals that the filter has changed
|
|
return false;
|
|
});
|
|
|
|
return tr;
|
|
};
|
|
|
|
this.getStringForGroup = function(group) {
|
|
var s = "(", index;
|
|
if (group.groups !== undefined) {
|
|
for (index = 0; index < group.groups.length; index++) {
|
|
if (s.length > 1) {
|
|
s += " " + group.groupOp + " ";
|
|
}
|
|
try {
|
|
s += this.getStringForGroup(group.groups[index]);
|
|
} catch (eg) {alert(eg);}
|
|
}
|
|
}
|
|
|
|
if (group.rules !== undefined) {
|
|
try{
|
|
for (index = 0; index < group.rules.length; index++) {
|
|
if (s.length > 1) {
|
|
s += " " + group.groupOp + " ";
|
|
}
|
|
s += this.getStringForRule(group.rules[index]);
|
|
}
|
|
} catch (e) {alert(e);}
|
|
}
|
|
|
|
s += ")";
|
|
|
|
if (s === "()") {
|
|
return ""; // ignore groups that don't have rules
|
|
} else {
|
|
return s;
|
|
}
|
|
};
|
|
this.getStringForRule = function(rule) {
|
|
var opUF = "",opC="", i, cm, ret, val,
|
|
numtypes = ['int', 'integer', 'float', 'number', 'currency']; // jqGrid
|
|
for (i = 0; i < this.p.ops.length; i++) {
|
|
if (this.p.ops[i].name === rule.op) {
|
|
opUF = this.p.ops[i].operator;
|
|
opC = this.p.ops[i].name;
|
|
break;
|
|
}
|
|
}
|
|
for (i=0; i<this.p.columns.length; i++) {
|
|
if(this.p.columns[i].name === rule.field) {
|
|
cm = this.p.columns[i];
|
|
break;
|
|
}
|
|
}
|
|
val = rule.data;
|
|
if(opC === 'bw' || opC === 'bn') { val = val+"%"; }
|
|
if(opC === 'ew' || opC === 'en') { val = "%"+val; }
|
|
if(opC === 'cn' || opC === 'nc') { val = "%"+val+"%"; }
|
|
if(opC === 'in' || opC === 'ni') { val = " ("+val+")"; }
|
|
if(p.errorcheck) { checkData(rule.data, cm); }
|
|
if($.inArray(cm.searchtype, numtypes) !== -1 || opC === 'nn' || opC === 'nu') { ret = rule.field + " " + opUF + " " + val; }
|
|
else { ret = rule.field + " " + opUF + " \"" + val + "\""; }
|
|
return ret;
|
|
};
|
|
this.resetFilter = function () {
|
|
this.p.filter = $.extend(true,{},this.p.initFilter);
|
|
this.reDraw();
|
|
this.onchange();
|
|
};
|
|
this.hideError = function() {
|
|
$("th.ui-state-error", this).html("");
|
|
$("tr.error", this).hide();
|
|
};
|
|
this.showError = function() {
|
|
$("th.ui-state-error", this).html(this.p.errmsg);
|
|
$("tr.error", this).show();
|
|
};
|
|
this.toUserFriendlyString = function() {
|
|
return this.getStringForGroup(p.filter);
|
|
};
|
|
this.toString = function() {
|
|
// this will obtain a string that can be used to match an item.
|
|
var that = this;
|
|
function getStringRule(rule) {
|
|
if(that.p.errorcheck) {
|
|
var i, cm;
|
|
for (i=0; i<that.p.columns.length; i++) {
|
|
if(that.p.columns[i].name === rule.field) {
|
|
cm = that.p.columns[i];
|
|
break;
|
|
}
|
|
}
|
|
if(cm) {checkData(rule.data, cm);}
|
|
}
|
|
return rule.op + "(item." + rule.field + ",'" + rule.data + "')";
|
|
}
|
|
|
|
function getStringForGroup(group) {
|
|
var s = "(", index;
|
|
|
|
if (group.groups !== undefined) {
|
|
for (index = 0; index < group.groups.length; index++) {
|
|
if (s.length > 1) {
|
|
if (group.groupOp === "OR") {
|
|
s += " || ";
|
|
}
|
|
else {
|
|
s += " && ";
|
|
}
|
|
}
|
|
s += getStringForGroup(group.groups[index]);
|
|
}
|
|
}
|
|
|
|
if (group.rules !== undefined) {
|
|
for (index = 0; index < group.rules.length; index++) {
|
|
if (s.length > 1) {
|
|
if (group.groupOp === "OR") {
|
|
s += " || ";
|
|
}
|
|
else {
|
|
s += " && ";
|
|
}
|
|
}
|
|
s += getStringRule(group.rules[index]);
|
|
}
|
|
}
|
|
|
|
s += ")";
|
|
|
|
if (s === "()") {
|
|
return ""; // ignore groups that don't have rules
|
|
} else {
|
|
return s;
|
|
}
|
|
}
|
|
|
|
return getStringForGroup(this.p.filter);
|
|
};
|
|
|
|
// Here we init the filter
|
|
this.reDraw();
|
|
|
|
if(this.p.showQuery) {
|
|
this.onchange();
|
|
}
|
|
// mark is as created so that it will not be created twice on this element
|
|
this.filter = true;
|
|
});
|
|
};
|
|
$.extend($.fn.jqFilter,{
|
|
/*
|
|
* Return SQL like string. Can be used directly
|
|
*/
|
|
toSQLString : function()
|
|
{
|
|
var s ="";
|
|
this.each(function(){
|
|
s = this.toUserFriendlyString();
|
|
});
|
|
return s;
|
|
},
|
|
/*
|
|
* Return filter data as object.
|
|
*/
|
|
filterData : function()
|
|
{
|
|
var s;
|
|
this.each(function(){
|
|
s = this.p.filter;
|
|
});
|
|
return s;
|
|
|
|
},
|
|
getParameter : function (param) {
|
|
if(param !== undefined) {
|
|
if (this.p.hasOwnProperty(param) ) {
|
|
return this.p[param];
|
|
}
|
|
}
|
|
return this.p;
|
|
},
|
|
resetFilter: function() {
|
|
return this.each(function(){
|
|
this.resetFilter();
|
|
});
|
|
}
|
|
|
|
});
|
|
})(jQuery);
|