/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
define(['require',
'backbone',
'hbs!tmpl/search/QueryBuilder_tmpl',
'hbs!tmpl/search/UserDefine_tmpl',
'utils/Utils',
'utils/CommonViewFunction',
'utils/Enums',
'utils/Globals',
'moment',
'query-builder',
'daterangepicker'
], function(require, Backbone, QueryBuilderTmpl, UserDefineTmpl, Utils, CommonViewFunction, Enums, Globals, moment) {
var QueryBuilderView = Backbone.Marionette.LayoutView.extend(
/** @lends QueryBuilderView */
{
_viewName: 'QueryBuilderView',
template: QueryBuilderTmpl,
/** Layout sub regions */
regions: {},
/** ui selector cache */
ui: {
"builder": "#builder"
},
/** ui events hash */
events: function() {
var events = {};
return events;
},
/**
* intialize a new QueryBuilderView Layout
* @constructs
*/
initialize: function(options) {
_.extend(this, _.pick(options, 'attrObj', 'value', 'typeHeaders', 'entityDefCollection', 'enumDefCollection', 'classificationDefCollection', 'businessMetadataDefCollection', 'tag', 'type', 'searchTableFilters', 'systemAttrArr', 'adminAttrFilters'));
this.attrObj = _.sortBy(this.attrObj, 'name');
this.filterType = this.tag ? 'tagFilters' : 'entityFilters';
this.defaultRange = "Last 7 Days";
this.dateRangesMap = {
'Today': [moment(), moment()],
'Yesterday': [moment().subtract(1, 'days'), moment().subtract(1, 'days')],
'Last 7 Days': [moment().subtract(6, 'days'), moment()],
'Last 30 Days': [moment().subtract(29, 'days'), moment()],
'This Month': [moment().startOf('month'), moment().endOf('month')],
'Last Month': [moment().subtract(1, 'month').startOf('month'), moment().subtract(1, 'month').endOf('month')],
'Last 3 Months': [moment().subtract(3, 'month').startOf('month'), moment().subtract(1, 'month').endOf('month')],
'Last 6 Months': [moment().subtract(6, 'month').startOf('month'), moment().subtract(1, 'month').endOf('month')],
'Last 12 Months': [moment().subtract(12, 'month').startOf('month'), moment().subtract(1, 'month').endOf('month')],
'This Quarter': [moment().startOf('quarter'), moment().endOf('quarter')],
'Last Quarter': [moment().subtract(1, 'quarter').startOf('quarter'), moment().subtract(1, 'quarter').endOf('quarter')],
'This Year': [moment().startOf('year'), moment().endOf('year')],
'Last Year': [moment().subtract(1, 'year').startOf('year'), moment().subtract(1, 'year').endOf('year')]
}
},
bindEvents: function() {},
getOperator: function(type, skipDefault) {
var obj = {
operators: null
}
if (type === "string") {
obj.operators = ['=', '!=', 'contains', 'begins_with', 'ends_with'];
if (this.adminAttrFilters) {
obj.operators = obj.operators.concat(['like', 'in']);
}
}
if (type === "date") {
obj.operators = ['=', '!=', '>', '<', '>=', '<=', 'TIME_RANGE'];
}
if (type === "int" || type === "byte" || type === "short" || type === "long" || type === "float" || type === "double") {
obj.operators = ['=', '!=', '>', '<', '>=', '<='];
}
if (type === "enum" || type === "boolean") {
obj.operators = ['=', '!='];
}
if (_.isEmpty(skipDefault) && obj.operators) {
obj.operators = obj.operators.concat(['is_null', 'not_null']);
}
return obj;
},
isPrimitive: function(type) {
if (type === "int" || type === "byte" || type === "short" || type === "long" || type === "float" || type === "double" || type === "string" || type === "boolean" || type === "date") {
return true;
}
return false;
},
getUserDefineInput: function() {
return UserDefineTmpl();
},
getObjDef: function(attrObj, rules, isGroup, groupType, isSystemAttr) {
var that = this;
if (attrObj.name === "__classificationsText" || attrObj.name === "__historicalGuids") {
return;
}
var getLableWithType = function(label, name) {
if (name === "__classificationNames" || name === "__customAttributes" || name === "__labels" || name === "__propagatedClassificationNames") {
return label;
} else {
return label + " (" + attrObj.typeName + ")";
}
}
var label = (Enums.systemAttributes[attrObj.name] ? Enums.systemAttributes[attrObj.name] : _.escape(attrObj.name.capitalize()));
var obj = {
id: attrObj.name,
label: getLableWithType(label, attrObj.name),
plainLabel: label,
type: _.escape(attrObj.typeName),
validation: {
callback: function(value, rule) {
if (rule.operator.nb_inputs === false || !_.isEmpty(value) || !value instanceof Error) {
return true;
} else {
if (value instanceof Error) {
return value.message; // with params
} else {
return rule.filter.plainLabel + ' is required'; // with params
}
}
}
}
};
if (isGroup) {
obj.optgroup = groupType;
}
/* __isIncomplete / IsIncomplete */
if (isSystemAttr && attrObj.name === "__isIncomplete" || isSystemAttr && attrObj.name === "IsIncomplete") {
obj.type = "boolean";
obj.label = (Enums.systemAttributes[attrObj.name] ? Enums.systemAttributes[attrObj.name] : _.escape(attrObj.name.capitalize())) + " (boolean)";
obj['input'] = 'select';
obj['values'] = [{ 1: 'true' }, { 0: 'false' }];
_.extend(obj, this.getOperator("boolean"));
return obj;
}
/* Status / __state */
if (isSystemAttr && attrObj.name === "Status" || isSystemAttr && attrObj.name === "__state" || isSystemAttr && attrObj.name === "__entityStatus") {
obj.label = (Enums.systemAttributes[attrObj.name] ? Enums.systemAttributes[attrObj.name] : _.escape(attrObj.name.capitalize())) + " (enum)";
obj['input'] = 'select';
obj['values'] = ['ACTIVE', 'DELETED'];
_.extend(obj, this.getOperator("boolean", true));
return obj;
}
/* __classificationNames / __propagatedClassificationNames */
if (isSystemAttr && attrObj.name === "__classificationNames" || attrObj.name === "__propagatedClassificationNames") {
obj["plugin"] = "select2";
obj["input"] = 'select';
obj["plugin_config"] = {
placeholder: "Select classfication",
tags: true,
multiple: false,
data: this.classificationDefCollection.fullCollection.models.map(function(o) { return { "id": o.get("name"), "text": o.get("name") } })
};
obj["valueSetter"] = function(rule) {
if (rule && !_.isEmpty(rule.value)) {
var selectEl = rule.$el.find('.rule-value-container select')
var valFound = that.classificationDefCollection.fullCollection.find(function(o) {
return o.get("name") === rule.value
})
if (valFound) {
selectEl.val(rule.value).trigger("change");
} else {
var newOption = new Option(rule.value, rule.value, false, false);
selectEl.append(newOption).val(rule.value);
}
}
};
_.extend(obj, this.getOperator("string"));
return obj;
}
/* __customAttributes */
if (isSystemAttr && attrObj.name === "__customAttributes") {
obj["input"] = function(rule) {
return rule.operator.nb_inputs ? that.getUserDefineInput() : null
}
obj["valueGetter"] = function(rule) {
if (rule.operator.type === "contains") {
var $el = rule.$el.find('.rule-value-container'),
key = $el.find("[data-type='key']").val(),
val = $el.find("[data-type='value']").val();
if (!_.isEmpty(key) && !_.isEmpty(val)) {
return key + "=" + val;
} else {
return new Error("Key & Value is Required");
}
}
}
obj["valueSetter"] = function(rule) {
if (!rule.$el.hasClass("user-define")) {
rule.$el.addClass("user-define");
}
if (rule.value && !(rule.value instanceof Error)) {
var $el = rule.$el.find('.rule-value-container'),
value = rule.value.split("=");
if (value) {
$el.find("[data-type='key']").val(value[0]),
$el.find("[data-type='value']").val(value[1]);
}
}
}
obj.operators = ['contains', 'is_null', 'not_null'];
return obj;
}
/* __labels */
if (isSystemAttr && attrObj.name === "__labels") {
obj["plugin"] = "select2";
obj["input"] = 'select';
obj["plugin_config"] = {
placeholder: "Enter Label(s)",
tags: true,
"language": {
"noResults": function() { return ''; }
},
multiple: false
};
obj["valueSetter"] = function(rule) {
if (rule && !_.isEmpty(rule.value)) {
var newOption = new Option(rule.value, rule.value, true, false);
return rule.$el.find('.rule-value-container select').append(newOption);
}
}
_.extend(obj, this.getOperator("string"));
return obj;
}
/* __typeName */
if (isSystemAttr && attrObj.name === "__typeName") {
var entityType = [];
that.typeHeaders.fullCollection.each(function(model) {
if ((that.type == true && model.get('category') == 'ENTITY') || (that.tag == true && model.get('category') == "CLASSIFICATION")) {
entityType.push({
"id": model.get("name"),
"text": model.get("name")
})
}
});
obj["plugin"] = "select2";
obj["input"] = 'select';
obj["plugin_config"] = {
placeholder: "Select type",
tags: true,
multiple: false,
data: entityType
};
obj["valueSetter"] = function(rule) {
if (rule && !_.isEmpty(rule.value)) {
var selectEl = rule.$el.find('.rule-value-container select')
var valFound = that.typeHeaders.fullCollection.find(function(o) {
return o.get("name") === rule.value
})
if (valFound) {
selectEl.val(rule.value).trigger("change");
} else {
var newOption = new Option(rule.value, rule.value, false, false);
selectEl.append(newOption).val(rule.value);
}
}
};
_.extend(obj, this.getOperator("string"));
return obj;
}
if (obj.type === "date") {
obj['plugin'] = 'daterangepicker';
obj['plugin_config'] = this.getDateConfig(rules, obj.id);
_.extend(obj, this.getOperator(obj.type));
return obj;
}
if (this.isPrimitive(obj.type)) {
if (obj.type === "boolean") {
obj['input'] = 'select';
obj['values'] = ['true', 'false'];
}
_.extend(obj, this.getOperator(obj.type, false));
if (_.has(Enums.regex.RANGE_CHECK, obj.type)) {
obj.validation = {
min: Enums.regex.RANGE_CHECK[obj.type].min,
max: Enums.regex.RANGE_CHECK[obj.type].max
};
if (obj.type === "double" || obj.type === "float") {
obj.type = "double";
} else if (obj.type === "int" || obj.type === "byte" || obj.type === "short" || obj.type === "long") {
obj.type = "integer"
}
}
return obj;
}
var enumObj = this.enumDefCollection.fullCollection.find({ name: obj.type });
if (enumObj) {
obj.type = "string";
obj['input'] = 'select';
var value = [];
_.each(enumObj.get('elementDefs'), function(o) {
value.push(o.value)
})
obj['values'] = value;
_.extend(obj, this.getOperator('enum'));
return obj;
}
},
getDateConfig: function(ruleObj, id, operator) {
var valueObj = ruleObj ? (_.find(ruleObj.rules, { id: id }) || {}) : {},
isTimeRange = (valueObj.operator && valueObj.operator === "TIME_RANGE" && operator === "TIME_RANGE") || (operator === "TIME_RANGE"),
obj = {
opens: "center",
autoApply: true,
autoUpdateInput: false,
timePickerSeconds: true,
timePicker: true,
locale: {
format: Globals.dateTimeFormat
}
};
if (isTimeRange) {
var defaultRangeDate = this.dateRangesMap[this.defaultRange];
obj.startDate = defaultRangeDate[0];
obj.endDate = defaultRangeDate[1];
obj.singleDatePicker = false;
obj.ranges = this.dateRangesMap;
} else {
obj.singleDatePicker = true;
obj.startDate = moment();
obj.endDate = obj.startDate;
}
if (!_.isEmpty(valueObj) && operator === valueObj.operator) {
if (isTimeRange) {
if (valueObj.value.indexOf("-") > -1) {
var dates = valueObj.value.split("-");
obj.startDate = dates[0].trim();
obj.endDate = dates[1].trim();
} else {
var dates = this.dateRangesMap[valueObj.value]
obj.startDate = dates[0];
obj.endDate = dates[1];
}
obj.singleDatePicker = false;
} else {
obj.startDate = moment(valueObj.value);
obj.endDate = moment(valueObj.value);
obj.singleDatePicker = true;
}
}
return obj;
},
setDateValue: function(rule, rules_widgets) {
if (rule.filter.type === "date" && rule.operator.nb_inputs) {
var inputEl = rule.$el.find(".rule-value-container").find("input"),
datepickerEl = rule.$el.find(".rule-value-container").find("input").data("daterangepicker")
inputEl.attr('readonly', true);
if (datepickerEl) {
datepickerEl.remove();
var configObj = this.getDateConfig(rules_widgets, rule.filter.id, rule.operator.type)
inputEl.daterangepicker(configObj);
if (rule.operator.type === "TIME_RANGE") {
rule.value = this.defaultRange;
} else {
rule.value = configObj.startDate.format(Globals.dateTimeFormat);
}
inputEl.on('apply.daterangepicker', function(ev, picker) {
picker.setStartDate(picker.startDate);
picker.setEndDate(picker.endDate);
var valueString = "";
if (picker.chosenLabel) {
if (picker.chosenLabel === "Custom Range") {
valueString = picker.startDate.format(Globals.dateTimeFormat) + " - " + picker.endDate.format(Globals.dateTimeFormat);
} else {
valueString = picker.chosenLabel;
}
} else {
valueString = picker.startDate.format(Globals.dateTimeFormat);
}
picker.element.val(valueString);
rule.value = valueString;
});
}
}
},
onRender: function() {
var that = this,
filters = [],
isGroupView = true,
placeHolder = '--Select Attribute--';
var rules_widgets = null;
if (this.adminAttrFilters) {
var entityDef = this.entityDefCollection.fullCollection.find({ name: "__AtlasAuditEntry" }),
auditEntryAttributeDefs = null;
if (entityDef) {
auditEntryAttributeDefs = $.extend(true, {}, entityDef.get("attributeDefs")) || null;
}
if (auditEntryAttributeDefs) {
_.each(auditEntryAttributeDefs, function(attributes) {
var returnObj = that.getObjDef(attributes, rules_widgets);
if (returnObj) {
filters.push(returnObj);
}
});
}
rules_widgets = CommonViewFunction.attributeFilter.extractUrl({ "value": this.searchTableFilters ? this.searchTableFilters["adminAttrFilters"] : null, "formatDate": true });;
} else {
if (this.value) {
rules_widgets = CommonViewFunction.attributeFilter.extractUrl({ "value": this.searchTableFilters[this.filterType][(this.tag ? this.value.tag : this.value.type)], "formatDate": true });
}
_.each(this.attrObj, function(obj) {
var type = that.tag ? that.value.tag : that.value.type;
var returnObj = that.getObjDef(obj, rules_widgets, isGroupView, (type + ' Attribute'));
if (returnObj) {
filters.push(returnObj);
}
});
var sortMap = {
"__guid": 1,
"__typeName": 2,
"__timestamp": 3,
"__modificationTimestamp": 4,
"__createdBy": 5,
"__modifiedBy": 6,
"__isIncomplete": 7,
"__classificationNames": 9,
"__propagatedClassificationNames": 10,
"__labels": 11,
"__customAttributes": 12,
}
if (that.type) {
sortMap["__state"] = 8;
} else {
sortMap["__entityStatus"] = 8;
}
this.systemAttrArr = _.sortBy(this.systemAttrArr, function(obj) {
return sortMap[obj.name]
})
_.each(this.systemAttrArr, function(obj) {
var returnObj = that.getObjDef(obj, rules_widgets, isGroupView, 'System Attribute', true);
if (returnObj) {
filters.push(returnObj);
}
});
if (this.type) {
var pushBusinessMetadataFilter = function(sortedAttributes, businessMetadataKey) {
_.each(sortedAttributes, function(attrDetails) {
var returnObj = that.getObjDef(attrDetails, rules_widgets, isGroupView, "Business Attributes: " + businessMetadataKey);
if (returnObj) {
returnObj.id = businessMetadataKey + "." + returnObj.id;
returnObj.label = returnObj.label;
returnObj.data = { 'entityType': "businessMetadata" };
filters.push(returnObj);
}
});
};
if (this.value.type == "_ALL_ENTITY_TYPES") {
this.businessMetadataDefCollection.each(function(model) {
var sortedAttributes = model.get('attributeDefs');
sortedAttributes = _.sortBy(sortedAttributes, function(obj) {
return obj.name;
});
pushBusinessMetadataFilter(sortedAttributes, model.get('name'));
})
} else {
var entityDef = this.entityDefCollection.fullCollection.find({ name: this.value.type }),
businessMetadataAttributeDefs = null;
if (entityDef) {
businessMetadataAttributeDefs = entityDef.get("businessAttributeDefs");
}
if (businessMetadataAttributeDefs) {
_.each(businessMetadataAttributeDefs, function(attributes, key) {
var sortedAttributes = _.sortBy(attributes, function(obj) {
return obj.name;
});
pushBusinessMetadataFilter(sortedAttributes, key);
});
}
}
}
}
filters = _.uniq(filters, 'id');
if (filters && !_.isEmpty(filters)) {
this.ui.builder.off()
.on("afterUpdateRuleOperator.queryBuilder", function(e, rule) {
that.setDateValue(rule, rules_widgets);
})
.queryBuilder({
plugins: ['bt-tooltip-errors'],
filters: filters,
select_placeholder: placeHolder,
allow_empty: true,
conditions: ['AND', 'OR'],
allow_groups: true,
allow_empty: true,
templates: {
rule: '<div id="{{= it.rule_id }}" class="rule-container"> \
<div class="values-box"><div class="rule-filter-container"></div> \
<div class="rule-operator-container"></div> \
<div class="rule-value-container"></div></div> \
<div class="action-box"><div class="rule-header"> \
<div class="btn-group rule-actions"> \
<button type="button" class="btn btn-xs btn-danger" data-delete="rule"> \
<i class="{{= it.icons.remove_rule }}"></i> \
</button> \
</div> \
</div> </div>\
{{? it.settings.display_errors }} \
<div class="error-container"><i class="{{= it.icons.error }}"></i> <span></span></div> \
{{?}} \
</div>'
},
operators: [
{ type: '=', nb_inputs: 1, multiple: false, apply_to: ['number', 'string', 'boolean', 'enum'] },
{ type: '!=', nb_inputs: 1, multiple: false, apply_to: ['number', 'string', 'boolean', 'enum'] },
{ type: '>', nb_inputs: 1, multiple: false, apply_to: ['number', 'string', 'boolean'] },
{ type: '<', nb_inputs: 1, multiple: false, apply_to: ['number', 'string', 'boolean'] },
{ type: '>=', nb_inputs: 1, multiple: false, apply_to: ['number', 'string', 'boolean'] },
{ type: '<=', nb_inputs: 1, multiple: false, apply_to: ['number', 'string', 'boolean'] },
{ type: 'contains', nb_inputs: 1, multiple: false, apply_to: ['string'] },
{ type: 'like', nb_inputs: 1, multiple: false, apply_to: ['string'] },
{ type: 'in', nb_inputs: 1, multiple: false, apply_to: ['string'] },
{ type: 'begins_with', nb_inputs: 1, multiple: false, apply_to: ['string'] },
{ type: 'ends_with', nb_inputs: 1, multiple: false, apply_to: ['string'] },
{ type: 'is_null', nb_inputs: false, multiple: false, apply_to: ['number', 'string', 'boolean', 'enum'] },
{ type: 'not_null', nb_inputs: false, multiple: false, apply_to: ['number', 'string', 'boolean', 'enum'] },
{ type: 'TIME_RANGE', nb_inputs: 1, multiple: false, apply_to: ['date'] }
],
lang: {
add_rule: 'Add filter',
add_group: 'Add filter group',
operators: {
not_null: 'is not null',
TIME_RANGE: "Time Range"
}
},
icons: {
add_rule: 'fa fa-plus',
remove_rule: 'fa fa-times',
error: 'fa fa-exclamation-triangle'
},
rules: rules_widgets
})
.on("afterCreateRuleInput.queryBuilder", function(e, rule) {
rule.error = null;
if (rule.operator.nb_inputs && rule.filter.id === "__customAttributes") {
rule.$el.addClass("user-define");
} else if (rule.$el.hasClass("user-define")) {
rule.$el.removeClass("user-define");
}
if (rule.filter.type === "date") {
rule.$el.find('.rule-value-container >input').attr('readonly', true)
}
that.setDateValue(rule, rules_widgets);
})
.on('validationError.queryBuilder', function(e, rule, error, value) {
// never display error for my custom filter
var errorMsg = error[0];
if (that.queryBuilderLang && that.queryBuilderLang.errors && that.queryBuilderLang.errors[errorMsg]) {
errorMsg = that.queryBuilderLang.errors[errorMsg];
}
rule.$el.find(".error-container span").html(errorMsg);
});
var queryBuilderEl = that.ui.builder.data("queryBuilder");
if (queryBuilderEl && queryBuilderEl.lang) {
this.queryBuilderLang = queryBuilderEl.lang;
}
this.$('.rules-group-header .btn-group.pull-right.group-actions').toggleClass('pull-left');
} else {
this.ui.builder.html('<h4>No Attributes are available !</h4>')
}
}
});
return QueryBuilderView;
});