You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2624 lines
130 KiB
2624 lines
130 KiB
/*! SearchPanes 1.2.1 |
|
* 2019-2020 SpryMedia Ltd - datatables.net/license |
|
*/ |
|
(function () { |
|
'use strict'; |
|
|
|
var $; |
|
var DataTable; |
|
function setJQuery(jq) { |
|
$ = jq; |
|
DataTable = jq.fn.dataTable; |
|
} |
|
var SearchPane = /** @class */ (function () { |
|
/** |
|
* Creates the panes, sets up the search function |
|
* @param paneSettings The settings for the searchPanes |
|
* @param opts The options for the default features |
|
* @param idx the index of the column for this pane |
|
* @returns {object} the pane that has been created, including the table and the index of the pane |
|
*/ |
|
function SearchPane(paneSettings, opts, idx, layout, panesContainer, panes) { |
|
var _this = this; |
|
if (panes === void 0) { panes = null; } |
|
// Check that the required version of DataTables is included |
|
if (!DataTable || !DataTable.versionCheck || !DataTable.versionCheck('1.10.0')) { |
|
throw new Error('SearchPane requires DataTables 1.10 or newer'); |
|
} |
|
// Check that Select is included |
|
if (!DataTable.select) { |
|
throw new Error('SearchPane requires Select'); |
|
} |
|
var table = new DataTable.Api(paneSettings); |
|
this.classes = $.extend(true, {}, SearchPane.classes); |
|
// Get options from user |
|
this.c = $.extend(true, {}, SearchPane.defaults, opts); |
|
this.customPaneSettings = panes; |
|
this.s = { |
|
cascadeRegen: false, |
|
clearing: false, |
|
colOpts: [], |
|
deselect: false, |
|
displayed: false, |
|
dt: table, |
|
dtPane: undefined, |
|
filteringActive: false, |
|
index: idx, |
|
indexes: [], |
|
lastCascade: false, |
|
lastSelect: false, |
|
listSet: false, |
|
name: undefined, |
|
redraw: false, |
|
rowData: { |
|
arrayFilter: [], |
|
arrayOriginal: [], |
|
arrayTotals: [], |
|
bins: {}, |
|
binsOriginal: {}, |
|
binsTotal: {}, |
|
filterMap: new Map(), |
|
totalOptions: 0 |
|
}, |
|
scrollTop: 0, |
|
searchFunction: undefined, |
|
selectPresent: false, |
|
serverSelect: [], |
|
serverSelecting: false, |
|
showFiltered: false, |
|
tableLength: null, |
|
updating: false |
|
}; |
|
var rowLength = table.columns().eq(0).toArray().length; |
|
this.colExists = this.s.index < rowLength; |
|
// Add extra elements to DOM object including clear and hide buttons |
|
this.c.layout = layout; |
|
var layVal = parseInt(layout.split('-')[1], 10); |
|
this.dom = { |
|
buttonGroup: $('<div/>').addClass(this.classes.buttonGroup), |
|
clear: $('<button type="button">×</button>') |
|
.addClass(this.classes.dull) |
|
.addClass(this.classes.paneButton) |
|
.addClass(this.classes.clearButton), |
|
container: $('<div/>').addClass(this.classes.container).addClass(this.classes.layout + |
|
(layVal < 10 ? layout : layout.split('-')[0] + '-9')), |
|
countButton: $('<button type="button"></button>') |
|
.addClass(this.classes.paneButton) |
|
.addClass(this.classes.countButton), |
|
dtP: $('<table><thead><tr><th>' + |
|
(this.colExists |
|
? $(table.column(this.colExists ? this.s.index : 0).header()).text() |
|
: this.customPaneSettings.header || 'Custom Pane') + '</th><th/></tr></thead></table>'), |
|
lower: $('<div/>').addClass(this.classes.subRow2).addClass(this.classes.narrowButton), |
|
nameButton: $('<button type="button"></button>').addClass(this.classes.paneButton).addClass(this.classes.nameButton), |
|
panesContainer: panesContainer, |
|
searchBox: $('<input/>').addClass(this.classes.paneInputButton).addClass(this.classes.search), |
|
searchButton: $('<button type = "button" class="' + this.classes.searchIcon + '"></button>') |
|
.addClass(this.classes.paneButton), |
|
searchCont: $('<div/>').addClass(this.classes.searchCont), |
|
searchLabelCont: $('<div/>').addClass(this.classes.searchLabelCont), |
|
topRow: $('<div/>').addClass(this.classes.topRow), |
|
upper: $('<div/>').addClass(this.classes.subRow1).addClass(this.classes.narrowSearch) |
|
}; |
|
this.s.displayed = false; |
|
table = this.s.dt; |
|
this.selections = []; |
|
this.s.colOpts = this.colExists ? this._getOptions() : this._getBonusOptions(); |
|
var colOpts = this.s.colOpts; |
|
var clear = $('<button type="button">X</button>').addClass(this.classes.paneButton); |
|
$(clear).text(table.i18n('searchPanes.clearPane', 'X')); |
|
this.dom.container.addClass(colOpts.className); |
|
this.dom.container.addClass((this.customPaneSettings !== null && this.customPaneSettings.className !== undefined) |
|
? this.customPaneSettings.className |
|
: ''); |
|
// Set the value of name incase ordering is desired |
|
if (this.s.colOpts.name !== undefined) { |
|
this.s.name = this.s.colOpts.name; |
|
} |
|
else if (this.customPaneSettings !== null && this.customPaneSettings.name !== undefined) { |
|
this.s.name = this.customPaneSettings.name; |
|
} |
|
else { |
|
this.s.name = this.colExists ? |
|
$(table.column(this.s.index).header()).text() : |
|
this.customPaneSettings.header || 'Custom Pane'; |
|
} |
|
$(panesContainer).append(this.dom.container); |
|
var tableNode = table.table(0).node(); |
|
// Custom search function for table |
|
this.s.searchFunction = function (settings, searchData, dataIndex, origData) { |
|
// If no data has been selected then show all |
|
if (_this.selections.length === 0) { |
|
return true; |
|
} |
|
if (settings.nTable !== tableNode) { |
|
return true; |
|
} |
|
var filter = null; |
|
if (_this.colExists) { |
|
// Get the current filtered data |
|
filter = searchData[_this.s.index]; |
|
if (colOpts.orthogonal.filter !== 'filter') { |
|
// get the filter value from the map |
|
filter = _this.s.rowData.filterMap.get(dataIndex); |
|
if (filter instanceof $.fn.dataTable.Api) { |
|
filter = filter.toArray(); |
|
} |
|
} |
|
} |
|
return _this._search(filter, dataIndex); |
|
}; |
|
$.fn.dataTable.ext.search.push(this.s.searchFunction); |
|
// If the clear button for this pane is clicked clear the selections |
|
if (this.c.clear) { |
|
$(clear).on('click', function () { |
|
var searches = _this.dom.container.find(_this.classes.search); |
|
searches.each(function () { |
|
$(this).val(''); |
|
$(this).trigger('input'); |
|
}); |
|
_this.clearPane(); |
|
}); |
|
} |
|
// Sometimes the top row of the panes containing the search box and ordering buttons appears |
|
// weird if the width of the panes is lower than expected, this fixes the design. |
|
// Equally this may occur when the table is resized. |
|
table.on('draw.dtsp', function () { |
|
_this._adjustTopRow(); |
|
}); |
|
table.on('buttons-action', function () { |
|
_this._adjustTopRow(); |
|
}); |
|
$(window).on('resize.dtsp', DataTable.util.throttle(function () { |
|
_this._adjustTopRow(); |
|
})); |
|
// When column-reorder is present and the columns are moved, it is necessary to |
|
// reassign all of the panes indexes to the new index of the column. |
|
table.on('column-reorder.dtsp', function (e, settings, details) { |
|
_this.s.index = details.mapping[_this.s.index]; |
|
}); |
|
return this; |
|
} |
|
/** |
|
* In the case of a rebuild there is potential for new data to have been included or removed |
|
* so all of the rowData must be reset as a precaution. |
|
*/ |
|
SearchPane.prototype.clearData = function () { |
|
this.s.rowData = { |
|
arrayFilter: [], |
|
arrayOriginal: [], |
|
arrayTotals: [], |
|
bins: {}, |
|
binsOriginal: {}, |
|
binsTotal: {}, |
|
filterMap: new Map(), |
|
totalOptions: 0 |
|
}; |
|
}; |
|
/** |
|
* Clear the selections in the pane |
|
*/ |
|
SearchPane.prototype.clearPane = function () { |
|
// Deselect all rows which are selected and update the table and filter count. |
|
this.s.dtPane.rows({ selected: true }).deselect(); |
|
this.updateTable(); |
|
return this; |
|
}; |
|
/** |
|
* Strips all of the SearchPanes elements from the document and turns all of the listeners for the buttons off |
|
*/ |
|
SearchPane.prototype.destroy = function () { |
|
$(this.s.dtPane).off('.dtsp'); |
|
$(this.s.dt).off('.dtsp'); |
|
$(this.dom.nameButton).off('.dtsp'); |
|
$(this.dom.countButton).off('.dtsp'); |
|
$(this.dom.clear).off('.dtsp'); |
|
$(this.dom.searchButton).off('.dtsp'); |
|
$(this.dom.container).remove(); |
|
var searchIdx = $.fn.dataTable.ext.search.indexOf(this.s.searchFunction); |
|
while (searchIdx !== -1) { |
|
$.fn.dataTable.ext.search.splice(searchIdx, 1); |
|
searchIdx = $.fn.dataTable.ext.search.indexOf(this.s.searchFunction); |
|
} |
|
// If the datatables have been defined for the panes then also destroy these |
|
if (this.s.dtPane !== undefined) { |
|
this.s.dtPane.destroy(); |
|
} |
|
this.s.listSet = false; |
|
}; |
|
/** |
|
* Updates the number of filters that have been applied in the title |
|
*/ |
|
SearchPane.prototype.getPaneCount = function () { |
|
return this.s.dtPane !== undefined ? |
|
this.s.dtPane.rows({ selected: true }).data().toArray().length : |
|
0; |
|
}; |
|
/** |
|
* Rebuilds the panes from the start having deleted the old ones |
|
* @param? last boolean to indicate if this is the last pane a selection was made in |
|
* @param? dataIn data to be used in buildPane |
|
* @param? init Whether this is the initial draw or not |
|
* @param? maintainSelection Whether the current selections are to be maintained over rebuild |
|
*/ |
|
SearchPane.prototype.rebuildPane = function (last, dataIn, init, maintainSelection) { |
|
if (last === void 0) { last = false; } |
|
if (dataIn === void 0) { dataIn = null; } |
|
if (init === void 0) { init = null; } |
|
if (maintainSelection === void 0) { maintainSelection = false; } |
|
this.clearData(); |
|
var selectedRows = []; |
|
this.s.serverSelect = []; |
|
var prevEl = null; |
|
// When rebuilding strip all of the HTML Elements out of the container and start from scratch |
|
if (this.s.dtPane !== undefined) { |
|
if (maintainSelection) { |
|
if (!this.s.dt.page.info().serverSide) { |
|
selectedRows = this.s.dtPane.rows({ selected: true }).data().toArray(); |
|
} |
|
else { |
|
this.s.serverSelect = this.s.dtPane.rows({ selected: true }).data().toArray(); |
|
} |
|
} |
|
this.s.dtPane.clear().destroy(); |
|
prevEl = $(this.dom.container).prev(); |
|
this.destroy(); |
|
this.s.dtPane = undefined; |
|
$.fn.dataTable.ext.search.push(this.s.searchFunction); |
|
} |
|
this.dom.container.removeClass(this.classes.hidden); |
|
this.s.displayed = false; |
|
this._buildPane(!this.s.dt.page.info().serverSide ? |
|
selectedRows : |
|
this.s.serverSelect, last, dataIn, init, prevEl); |
|
return this; |
|
}; |
|
/** |
|
* removes the pane from the page and sets the displayed property to false. |
|
*/ |
|
SearchPane.prototype.removePane = function () { |
|
this.s.displayed = false; |
|
$(this.dom.container).hide(); |
|
}; |
|
/** |
|
* Sets the cascadeRegen property of the pane. Accessible from above because as SearchPanes.ts deals with the rebuilds. |
|
* @param val the boolean value that the cascadeRegen property is to be set to |
|
*/ |
|
SearchPane.prototype.setCascadeRegen = function (val) { |
|
this.s.cascadeRegen = val; |
|
}; |
|
/** |
|
* This function allows the clearing property to be assigned. This is used when implementing cascadePane. |
|
* In setting this to true for the clearing of the panes selection on the deselects it forces the pane to |
|
* repopulate from the entire dataset not just the displayed values. |
|
* @param val the boolean value which the clearing property is to be assigned |
|
*/ |
|
SearchPane.prototype.setClear = function (val) { |
|
this.s.clearing = val; |
|
}; |
|
/** |
|
* Updates the values of all of the panes |
|
* @param draw whether this has been triggered by a draw event or not |
|
*/ |
|
SearchPane.prototype.updatePane = function (draw) { |
|
if (draw === void 0) { draw = false; } |
|
this.s.updating = true; |
|
this._updateCommon(draw); |
|
this.s.updating = false; |
|
}; |
|
/** |
|
* Updates the panes if one of the options to do so has been set to true |
|
* rather than the filtered message when using viewTotal. |
|
*/ |
|
SearchPane.prototype.updateTable = function () { |
|
var selectedRows = this.s.dtPane.rows({ selected: true }).data().toArray(); |
|
this.selections = selectedRows; |
|
this._searchExtras(); |
|
// If either of the options that effect how the panes are displayed are selected then update the Panes |
|
if (this.c.cascadePanes || this.c.viewTotal) { |
|
this.updatePane(); |
|
} |
|
}; |
|
/** |
|
* Sets the listeners for the pane. |
|
* |
|
* Having it in it's own function makes it easier to only set them once |
|
*/ |
|
SearchPane.prototype._setListeners = function () { |
|
var _this = this; |
|
var rowData = this.s.rowData; |
|
var t0; |
|
// When an item is selected on the pane, add these to the array which holds selected items. |
|
// Custom search will perform. |
|
this.s.dtPane.on('select.dtsp', function () { |
|
clearTimeout(t0); |
|
if (_this.s.dt.page.info().serverSide && !_this.s.updating) { |
|
if (!_this.s.serverSelecting) { |
|
_this.s.serverSelect = _this.s.dtPane.rows({ selected: true }).data().toArray(); |
|
_this.s.scrollTop = $(_this.s.dtPane.table().node()).parent()[0].scrollTop; |
|
_this.s.selectPresent = true; |
|
_this.s.dt.draw(false); |
|
} |
|
} |
|
else { |
|
$(_this.dom.clear).removeClass(_this.classes.dull); |
|
_this.s.selectPresent = true; |
|
if (!_this.s.updating) { |
|
_this._makeSelection(); |
|
} |
|
_this.s.selectPresent = false; |
|
} |
|
}); |
|
// When an item is deselected on the pane, re add the currently selected items to the array |
|
// which holds selected items. Custom search will be performed. |
|
this.s.dtPane.on('deselect.dtsp', function () { |
|
t0 = setTimeout(function () { |
|
if (_this.s.dt.page.info().serverSide && !_this.s.updating) { |
|
if (!_this.s.serverSelecting) { |
|
_this.s.serverSelect = _this.s.dtPane.rows({ selected: true }).data().toArray(); |
|
_this.s.deselect = true; |
|
_this.s.dt.draw(false); |
|
} |
|
} |
|
else { |
|
_this.s.deselect = true; |
|
if (_this.s.dtPane.rows({ selected: true }).data().toArray().length === 0) { |
|
$(_this.dom.clear).addClass(_this.classes.dull); |
|
} |
|
_this._makeSelection(); |
|
_this.s.deselect = false; |
|
_this.s.dt.state.save(); |
|
} |
|
}, 50); |
|
}); |
|
// When saving the state store all of the selected rows for preselection next time around |
|
this.s.dt.on('stateSaveParams.dtsp', function (e, settings, data) { |
|
// If the data being passed in is empty then a state clear must have occured so clear the panes state as well |
|
if ($.isEmptyObject(data)) { |
|
_this.s.dtPane.state.clear(); |
|
return; |
|
} |
|
var selected = []; |
|
var searchTerm; |
|
var order; |
|
var bins; |
|
var arrayFilter; |
|
// Get all of the data needed for the state save from the pane |
|
if (_this.s.dtPane !== undefined) { |
|
selected = _this.s.dtPane.rows({ selected: true }).data().map(function (item) { return item.filter.toString(); }).toArray(); |
|
searchTerm = $(_this.dom.searchBox).val(); |
|
order = _this.s.dtPane.order(); |
|
bins = rowData.binsOriginal; |
|
arrayFilter = rowData.arrayOriginal; |
|
} |
|
if (data.searchPanes === undefined) { |
|
data.searchPanes = {}; |
|
} |
|
if (data.searchPanes.panes === undefined) { |
|
data.searchPanes.panes = []; |
|
} |
|
for (var i = 0; i < data.searchPanes.panes.length; i++) { |
|
if (data.searchPanes.panes[i].id === _this.s.index) { |
|
data.searchPanes.panes.splice(i, 1); |
|
i--; |
|
} |
|
} |
|
// Add the panes data to the state object |
|
data.searchPanes.panes.push({ |
|
arrayFilter: arrayFilter, |
|
bins: bins, |
|
id: _this.s.index, |
|
order: order, |
|
searchTerm: searchTerm, |
|
selected: selected |
|
}); |
|
}); |
|
this.s.dtPane.on('user-select.dtsp', function (e, _dt, type, cell, originalEvent) { |
|
originalEvent.stopPropagation(); |
|
}); |
|
this.s.dtPane.on('draw.dtsp', function () { |
|
_this._adjustTopRow(); |
|
}); |
|
// When the button to order by the name of the options is clicked then |
|
// change the ordering to whatever it isn't currently |
|
$(this.dom.nameButton).on('click.dtsp', function () { |
|
var currentOrder = _this.s.dtPane.order()[0][1]; |
|
_this.s.dtPane.order([0, currentOrder === 'asc' ? 'desc' : 'asc']).draw(); |
|
_this.s.dt.state.save(); |
|
}); |
|
// When the button to order by the number of entries in the column is clicked then |
|
// change the ordering to whatever it isn't currently |
|
$(this.dom.countButton).on('click.dtsp', function () { |
|
var currentOrder = _this.s.dtPane.order()[0][1]; |
|
_this.s.dtPane.order([1, currentOrder === 'asc' ? 'desc' : 'asc']).draw(); |
|
_this.s.dt.state.save(); |
|
}); |
|
// When the clear button is clicked reset the pane |
|
$(this.dom.clear).on('click.dtsp', function () { |
|
var searches = _this.dom.container.find('.' + _this.classes.search); |
|
searches.each(function () { |
|
// set the value of the search box to be an empty string and then search on that, effectively reseting |
|
$(this).val(''); |
|
$(this).trigger('input'); |
|
}); |
|
_this.clearPane(); |
|
}); |
|
// When the search button is clicked then draw focus to the search box |
|
$(this.dom.searchButton).on('click.dtsp', function () { |
|
$(_this.dom.searchBox).focus(); |
|
}); |
|
// When a character is inputted into the searchbox search the pane for matching values. |
|
// Doing it this way means that no button has to be clicked to trigger a search, it is done asynchronously |
|
$(this.dom.searchBox).on('input.dtsp', function () { |
|
_this.s.dtPane.search($(_this.dom.searchBox).val()).draw(); |
|
_this.s.dt.state.save(); |
|
}); |
|
// Make sure to save the state once the pane has been built |
|
this.s.dt.state.save(); |
|
return true; |
|
}; |
|
/** |
|
* Takes in potentially undetected rows and adds them to the array if they are not yet featured |
|
* @param filter the filter value of the potential row |
|
* @param display the display value of the potential row |
|
* @param sort the sort value of the potential row |
|
* @param type the type value of the potential row |
|
* @param arrayFilter the array to be populated |
|
* @param bins the bins to be populated |
|
*/ |
|
SearchPane.prototype._addOption = function (filter, display, sort, type, arrayFilter, bins) { |
|
// If the filter is an array then take a note of this, and add the elements to the arrayFilter array |
|
if (Array.isArray(filter) || filter instanceof DataTable.Api) { |
|
// Convert to an array so that we can work with it |
|
if (filter instanceof DataTable.Api) { |
|
filter = filter.toArray(); |
|
display = display.toArray(); |
|
} |
|
if (filter.length === display.length) { |
|
for (var i = 0; i < filter.length; i++) { |
|
// If we haven't seen this row before add it |
|
if (!bins[filter[i]]) { |
|
bins[filter[i]] = 1; |
|
arrayFilter.push({ |
|
display: display[i], |
|
filter: filter[i], |
|
sort: sort[i], |
|
type: type[i] |
|
}); |
|
} |
|
// Otherwise just increment the count |
|
else { |
|
bins[filter[i]]++; |
|
} |
|
this.s.rowData.totalOptions++; |
|
} |
|
return; |
|
} |
|
else { |
|
throw new Error('display and filter not the same length'); |
|
} |
|
} |
|
// If the values were affected by othogonal data and are not an array then check if it is already present |
|
else if (typeof this.s.colOpts.orthogonal === 'string') { |
|
if (!bins[filter]) { |
|
bins[filter] = 1; |
|
arrayFilter.push({ |
|
display: display, |
|
filter: filter, |
|
sort: sort, |
|
type: type |
|
}); |
|
this.s.rowData.totalOptions++; |
|
} |
|
else { |
|
bins[filter]++; |
|
this.s.rowData.totalOptions++; |
|
return; |
|
} |
|
} |
|
// Otherwise we must just be adding an option |
|
else { |
|
arrayFilter.push({ |
|
display: display, |
|
filter: filter, |
|
sort: sort, |
|
type: type |
|
}); |
|
} |
|
}; |
|
/** |
|
* Adds a row to the panes table |
|
* @param display the value to be displayed to the user |
|
* @param filter the value to be filtered on when searchpanes is implemented |
|
* @param shown the number of rows in the table that are currently visible matching this criteria |
|
* @param total the total number of rows in the table that match this criteria |
|
* @param sort the value to be sorted in the pane table |
|
* @param type the value of which the type is to be derived from |
|
*/ |
|
SearchPane.prototype._addRow = function (display, filter, shown, total, sort, type, className) { |
|
var index; |
|
for (var _i = 0, _a = this.s.indexes; _i < _a.length; _i++) { |
|
var entry = _a[_i]; |
|
if (entry.filter === filter) { |
|
index = entry.index; |
|
} |
|
} |
|
if (index === undefined) { |
|
index = this.s.indexes.length; |
|
this.s.indexes.push({ filter: filter, index: index }); |
|
} |
|
return this.s.dtPane.row.add({ |
|
className: className, |
|
display: display !== '' ? |
|
display : |
|
this.s.colOpts.emptyMessage !== false ? |
|
this.s.colOpts.emptyMessage : |
|
this.c.emptyMessage, |
|
filter: filter, |
|
index: index, |
|
shown: shown, |
|
sort: sort !== '' ? |
|
sort : |
|
this.s.colOpts.emptyMessage !== false ? |
|
this.s.colOpts.emptyMessage : |
|
this.c.emptyMessage, |
|
total: total, |
|
type: type |
|
}); |
|
}; |
|
/** |
|
* Adjusts the layout of the top row when the screen is resized |
|
*/ |
|
SearchPane.prototype._adjustTopRow = function () { |
|
var subContainers = this.dom.container.find('.' + this.classes.subRowsContainer); |
|
var subRow1 = this.dom.container.find('.dtsp-subRow1'); |
|
var subRow2 = this.dom.container.find('.dtsp-subRow2'); |
|
var topRow = this.dom.container.find('.' + this.classes.topRow); |
|
// If the width is 0 then it is safe to assume that the pane has not yet been displayed. |
|
// Even if it has, if the width is 0 it won't make a difference if it has the narrow class or not |
|
if (($(subContainers[0]).width() < 252 || $(topRow[0]).width() < 252) && $(subContainers[0]).width() !== 0) { |
|
$(subContainers[0]).addClass(this.classes.narrow); |
|
$(subRow1[0]).addClass(this.classes.narrowSub).removeClass(this.classes.narrowSearch); |
|
$(subRow2[0]).addClass(this.classes.narrowSub).removeClass(this.classes.narrowButton); |
|
} |
|
else { |
|
$(subContainers[0]).removeClass(this.classes.narrow); |
|
$(subRow1[0]).removeClass(this.classes.narrowSub).addClass(this.classes.narrowSearch); |
|
$(subRow2[0]).removeClass(this.classes.narrowSub).addClass(this.classes.narrowButton); |
|
} |
|
}; |
|
/** |
|
* Method to construct the actual pane. |
|
* @param selectedRows previously selected Rows to be reselected |
|
* @last boolean to indicate whether this pane was the last one to have a selection made |
|
*/ |
|
SearchPane.prototype._buildPane = function (selectedRows, last, dataIn, init, prevEl) { |
|
var _this = this; |
|
if (selectedRows === void 0) { selectedRows = []; } |
|
if (last === void 0) { last = false; } |
|
if (dataIn === void 0) { dataIn = null; } |
|
if (init === void 0) { init = null; } |
|
if (prevEl === void 0) { prevEl = null; } |
|
// Aliases |
|
this.selections = []; |
|
var table = this.s.dt; |
|
var column = table.column(this.colExists ? this.s.index : 0); |
|
var colOpts = this.s.colOpts; |
|
var rowData = this.s.rowData; |
|
// Other Variables |
|
var countMessage = table.i18n('searchPanes.count', '{total}'); |
|
var filteredMessage = table.i18n('searchPanes.countFiltered', '{shown} ({total})'); |
|
var loadedFilter = table.state.loaded(); |
|
// If the listeners have not been set yet then using the latest state may result in funny errors |
|
if (this.s.listSet) { |
|
loadedFilter = table.state(); |
|
} |
|
// If it is not a custom pane in place |
|
if (this.colExists) { |
|
var idx = -1; |
|
if (loadedFilter && loadedFilter.searchPanes && loadedFilter.searchPanes.panes) { |
|
for (var i = 0; i < loadedFilter.searchPanes.panes.length; i++) { |
|
if (loadedFilter.searchPanes.panes[i].id === this.s.index) { |
|
idx = i; |
|
break; |
|
} |
|
} |
|
} |
|
// Perform checks that do not require populate pane to run |
|
if ((colOpts.show === false |
|
|| (colOpts.show !== undefined && colOpts.show !== true)) && |
|
idx === -1) { |
|
this.dom.container.addClass(this.classes.hidden); |
|
this.s.displayed = false; |
|
return false; |
|
} |
|
else if (colOpts.show === true || idx !== -1) { |
|
this.s.displayed = true; |
|
} |
|
if (!this.s.dt.page.info().serverSide && |
|
(dataIn === null || |
|
dataIn.searchPanes === null || |
|
dataIn.searchPanes.options === null)) { |
|
// Only run populatePane if the data has not been collected yet |
|
if (rowData.arrayFilter.length === 0) { |
|
this._populatePane(last); |
|
this.s.rowData.totalOptions = 0; |
|
this._detailsPane(); |
|
// If the index is not found then no data has been added to the state for this pane, |
|
// which will only occur if it has previously failed to meet the criteria to be |
|
// displayed, therefore we can just hide it again here |
|
if (loadedFilter && loadedFilter.searchPanes && loadedFilter.searchPanes.panes && idx === -1) { |
|
this.dom.container.addClass(this.classes.hidden); |
|
this.s.displayed = false; |
|
return; |
|
} |
|
rowData.arrayOriginal = rowData.arrayTotals; |
|
rowData.binsOriginal = rowData.binsTotal; |
|
} |
|
var binLength = Object.keys(rowData.binsOriginal).length; |
|
var uniqueRatio = this._uniqueRatio(binLength, table.rows()[0].length); |
|
// Don't show the pane if there isn't enough variance in the data, or there is only 1 entry for that pane |
|
if (this.s.displayed === false && ((colOpts.show === undefined && colOpts.threshold === null ? |
|
uniqueRatio > this.c.threshold : |
|
uniqueRatio > colOpts.threshold) |
|
|| (colOpts.show !== true && binLength <= 1))) { |
|
this.dom.container.addClass(this.classes.hidden); |
|
this.s.displayed = false; |
|
return; |
|
} |
|
// If the option viewTotal is true then find |
|
// the total count for the whole table to display alongside the displayed count |
|
if (this.c.viewTotal && rowData.arrayTotals.length === 0) { |
|
this.s.rowData.totalOptions = 0; |
|
this._detailsPane(); |
|
} |
|
else { |
|
rowData.binsTotal = rowData.bins; |
|
} |
|
this.dom.container.addClass(this.classes.show); |
|
this.s.displayed = true; |
|
} |
|
else if (dataIn !== null && dataIn.searchPanes !== null && dataIn.searchPanes.options !== null) { |
|
if (dataIn.tableLength !== undefined) { |
|
this.s.tableLength = dataIn.tableLength; |
|
this.s.rowData.totalOptions = this.s.tableLength; |
|
} |
|
else if (this.s.tableLength === null || table.rows()[0].length > this.s.tableLength) { |
|
this.s.tableLength = table.rows()[0].length; |
|
this.s.rowData.totalOptions = this.s.tableLength; |
|
} |
|
var colTitle = table.column(this.s.index).dataSrc(); |
|
if (dataIn.searchPanes.options[colTitle] !== undefined) { |
|
for (var _i = 0, _a = dataIn.searchPanes.options[colTitle]; _i < _a.length; _i++) { |
|
var dataPoint = _a[_i]; |
|
this.s.rowData.arrayFilter.push({ |
|
display: dataPoint.label, |
|
filter: dataPoint.value, |
|
sort: dataPoint.label, |
|
type: dataPoint.label |
|
}); |
|
this.s.rowData.bins[dataPoint.value] = this.c.viewTotal || this.c.cascadePanes ? |
|
dataPoint.count : |
|
dataPoint.total; |
|
this.s.rowData.binsTotal[dataPoint.value] = dataPoint.total; |
|
} |
|
} |
|
var binLength = Object.keys(rowData.binsTotal).length; |
|
var uniqueRatio = this._uniqueRatio(binLength, this.s.tableLength); |
|
// Don't show the pane if there isn't enough variance in the data, or there is only 1 entry for that pane |
|
if (this.s.displayed === false && ((colOpts.show === undefined && colOpts.threshold === null ? |
|
uniqueRatio > this.c.threshold : |
|
uniqueRatio > colOpts.threshold) |
|
|| (colOpts.show !== true && binLength <= 1))) { |
|
this.dom.container.addClass(this.classes.hidden); |
|
this.s.displayed = false; |
|
return; |
|
} |
|
this.s.rowData.arrayOriginal = this.s.rowData.arrayFilter; |
|
this.s.rowData.binsOriginal = this.s.rowData.bins; |
|
this.s.displayed = true; |
|
} |
|
} |
|
else { |
|
this.s.displayed = true; |
|
} |
|
// If the variance is accceptable then display the search pane |
|
this._displayPane(); |
|
if (!this.s.listSet) { |
|
// Here, when the state is loaded if the data object on the original table is empty, |
|
// then a state.clear() must have occurred, so delete all of the panes tables state objects too. |
|
this.dom.dtP.on('stateLoadParams.dt', function (e, settings, data) { |
|
if ($.isEmptyObject(table.state.loaded())) { |
|
$.each(data, function (index, value) { |
|
delete data[index]; |
|
}); |
|
} |
|
}); |
|
} |
|
// Add the container to the document in its original location |
|
if (prevEl !== null && $(this.dom.panesContainer).has(prevEl).length > 0) { |
|
$(this.dom.container).insertAfter(prevEl); |
|
} |
|
else { |
|
$(this.dom.panesContainer).prepend(this.dom.container); |
|
} |
|
// Declare the datatable for the pane |
|
var errMode = $.fn.dataTable.ext.errMode; |
|
$.fn.dataTable.ext.errMode = 'none'; |
|
var haveScroller = DataTable.Scroller; |
|
this.s.dtPane = $(this.dom.dtP).DataTable($.extend(true, { |
|
columnDefs: [ |
|
{ |
|
className: 'dtsp-nameColumn', |
|
data: 'display', |
|
render: function (data, type, row) { |
|
if (type === 'sort') { |
|
return row.sort; |
|
} |
|
else if (type === 'type') { |
|
return row.type; |
|
} |
|
var message; |
|
(_this.s.filteringActive || _this.s.showFiltered) && _this.c.viewTotal |
|
? message = filteredMessage.replace(/{total}/, row.total) |
|
: message = countMessage.replace(/{total}/, row.total); |
|
message = message.replace(/{shown}/, row.shown); |
|
while (message.indexOf('{total}') !== -1) { |
|
message = message.replace(/{total}/, row.total); |
|
} |
|
while (message.indexOf('{shown}') !== -1) { |
|
message = message.replace(/{shown}/, row.shown); |
|
} |
|
// We are displaying the count in the same columne as the name of the search option. |
|
// This is so that there is not need to call columns.adjust(), which in turn speeds up the code |
|
var pill = '<span class="' + _this.classes.pill + '">' + message + '</span>'; |
|
if (_this.c.hideCount || colOpts.hideCount) { |
|
pill = ''; |
|
} |
|
return '<div class="' + _this.classes.nameCont + '"><span title="' + |
|
(typeof data === 'string' && data.match(/<[^>]*>/) !== null ? data.replace(/<[^>]*>/g, '') : data) + |
|
'" class="' + _this.classes.name + '">' + |
|
data + '</span>' + |
|
pill + '</div>'; |
|
}, |
|
targets: 0, |
|
// Accessing the private datatables property to set type based on the original table. |
|
// This is null if not defined by the user, meaning that automatic type detection would take place |
|
type: table.settings()[0].aoColumns[this.s.index] !== undefined ? |
|
table.settings()[0].aoColumns[this.s.index]._sManualType : |
|
null |
|
}, |
|
{ |
|
className: 'dtsp-countColumn ' + this.classes.badgePill, |
|
data: 'shown', |
|
orderData: [1, 2], |
|
targets: 1, |
|
visible: false |
|
}, |
|
{ |
|
data: 'total', |
|
targets: 2, |
|
visible: false |
|
} |
|
], |
|
deferRender: true, |
|
dom: 't', |
|
info: false, |
|
language: this.s.dt.settings()[0].oLanguage, |
|
paging: haveScroller ? true : false, |
|
scrollX: false, |
|
scrollY: '200px', |
|
scroller: haveScroller ? true : false, |
|
select: true, |
|
stateSave: table.settings()[0].oFeatures.bStateSave ? true : false |
|
}, this.c.dtOpts, colOpts !== undefined ? colOpts.dtOpts : {}, (this.s.colOpts.options !== undefined || !this.colExists) |
|
? { |
|
createdRow: function (row, data, dataIndex) { |
|
$(row).addClass(data.className); |
|
} |
|
} |
|
: undefined, (this.customPaneSettings !== null && this.customPaneSettings.dtOpts !== undefined) |
|
? this.customPaneSettings.dtOpts |
|
: {})); |
|
$(this.dom.dtP).addClass(this.classes.table); |
|
// This is hacky but necessary for when datatables is generating the column titles automatically |
|
$(this.dom.searchBox).attr('placeholder', colOpts.header !== undefined |
|
? colOpts.header |
|
: this.colExists |
|
? table.settings()[0].aoColumns[this.s.index].sTitle |
|
: this.customPaneSettings.header || 'Custom Pane'); |
|
// As the pane table is not in the document yet we must initialise select ourselves |
|
$.fn.dataTable.select.init(this.s.dtPane); |
|
$.fn.dataTable.ext.errMode = errMode; |
|
// If it is not a custom pane |
|
if (this.colExists) { |
|
// On initialisation, do we need to set a filtering value from a |
|
// saved state or init option? |
|
var search = column.search(); |
|
search = search ? search.substr(1, search.length - 2).split('|') : []; |
|
// Count the number of empty cells |
|
var count_1 = 0; |
|
rowData.arrayFilter.forEach(function (element) { |
|
if (element.filter === '') { |
|
count_1++; |
|
} |
|
}); |
|
// Add all of the search options to the pane |
|
for (var i = 0, ien = rowData.arrayFilter.length; i < ien; i++) { |
|
var selected = false; |
|
for (var _b = 0, _c = this.s.serverSelect; _b < _c.length; _b++) { |
|
var option = _c[_b]; |
|
if (option.filter === rowData.arrayFilter[i].filter) { |
|
selected = true; |
|
} |
|
} |
|
if (this.s.dt.page.info().serverSide && |
|
(!this.c.cascadePanes || |
|
(this.c.cascadePanes && rowData.bins[rowData.arrayFilter[i].filter] !== 0) || |
|
(this.c.cascadePanes && init !== null) || |
|
selected)) { |
|
var row = this._addRow(rowData.arrayFilter[i].display, rowData.arrayFilter[i].filter, init ? |
|
rowData.binsTotal[rowData.arrayFilter[i].filter] : |
|
rowData.bins[rowData.arrayFilter[i].filter], this.c.viewTotal || init |
|
? String(rowData.binsTotal[rowData.arrayFilter[i].filter]) |
|
: rowData.bins[rowData.arrayFilter[i].filter], rowData.arrayFilter[i].sort, rowData.arrayFilter[i].type); |
|
for (var _d = 0, _e = this.s.serverSelect; _d < _e.length; _d++) { |
|
var option = _e[_d]; |
|
if (option.filter === rowData.arrayFilter[i].filter) { |
|
this.s.serverSelecting = true; |
|
row.select(); |
|
this.s.serverSelecting = false; |
|
} |
|
} |
|
} |
|
else if (!this.s.dt.page.info().serverSide && |
|
rowData.arrayFilter[i] && |
|
(rowData.bins[rowData.arrayFilter[i].filter] !== undefined || !this.c.cascadePanes)) { |
|
this._addRow(rowData.arrayFilter[i].display, rowData.arrayFilter[i].filter, rowData.bins[rowData.arrayFilter[i].filter], rowData.binsTotal[rowData.arrayFilter[i].filter], rowData.arrayFilter[i].sort, rowData.arrayFilter[i].type); |
|
} |
|
else if (!this.s.dt.page.info().serverSide) { |
|
// Just pass an empty string as the message will be calculated based on that in _addRow() |
|
this._addRow('', count_1, count_1, '', '', ''); |
|
} |
|
} |
|
} |
|
DataTable.select.init(this.s.dtPane); |
|
// If there are custom options set or it is a custom pane then get them |
|
if (colOpts.options !== undefined || |
|
(this.customPaneSettings !== null && this.customPaneSettings.options !== undefined)) { |
|
this._getComparisonRows(); |
|
} |
|
// Display the pane |
|
this.s.dtPane.draw(); |
|
this._adjustTopRow(); |
|
if (!this.s.listSet) { |
|
this._setListeners(); |
|
this.s.listSet = true; |
|
} |
|
for (var _f = 0, selectedRows_1 = selectedRows; _f < selectedRows_1.length; _f++) { |
|
var selection = selectedRows_1[_f]; |
|
if (selection !== undefined) { |
|
for (var _g = 0, _h = this.s.dtPane.rows().indexes().toArray(); _g < _h.length; _g++) { |
|
var row = _h[_g]; |
|
if (this.s.dtPane.row(row).data() !== undefined && selection.filter === this.s.dtPane.row(row).data().filter) { |
|
// If this is happening when serverSide processing is happening then different behaviour is needed |
|
if (this.s.dt.page.info().serverSide) { |
|
this.s.serverSelecting = true; |
|
this.s.dtPane.row(row).select(); |
|
this.s.serverSelecting = false; |
|
} |
|
else { |
|
this.s.dtPane.row(row).select(); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
// If SSP and the table is ready, apply the search for the pane |
|
if (this.s.dt.page.info().serverSide) { |
|
this.s.dtPane.search($(this.dom.searchBox).val()).draw(); |
|
} |
|
// Reload the selection, searchbox entry and ordering from the previous state |
|
// Need to check here if SSP that this is the first draw, otherwise it will infinite loop |
|
if (loadedFilter && |
|
loadedFilter.searchPanes && |
|
loadedFilter.searchPanes.panes && |
|
(dataIn === null || |
|
dataIn.draw === 1)) { |
|
if (!this.c.cascadePanes) { |
|
this._reloadSelect(loadedFilter); |
|
} |
|
for (var _j = 0, _k = loadedFilter.searchPanes.panes; _j < _k.length; _j++) { |
|
var pane = _k[_j]; |
|
if (pane.id === this.s.index) { |
|
$(this.dom.searchBox).val(pane.searchTerm); |
|
$(this.dom.searchBox).trigger('input'); |
|
this.s.dtPane.order(pane.order).draw(); |
|
} |
|
} |
|
} |
|
// Make sure to save the state once the pane has been built |
|
this.s.dt.state.save(); |
|
return true; |
|
}; |
|
/** |
|
* Update the array which holds the display and filter values for the table |
|
*/ |
|
SearchPane.prototype._detailsPane = function () { |
|
var table = this.s.dt; |
|
this.s.rowData.arrayTotals = []; |
|
this.s.rowData.binsTotal = {}; |
|
var settings = this.s.dt.settings()[0]; |
|
var indexArray = table.rows().indexes(); |
|
if (!this.s.dt.page.info().serverSide) { |
|
for (var _i = 0, indexArray_1 = indexArray; _i < indexArray_1.length; _i++) { |
|
var rowIdx = indexArray_1[_i]; |
|
this._populatePaneArray(rowIdx, this.s.rowData.arrayTotals, settings, this.s.rowData.binsTotal); |
|
} |
|
} |
|
}; |
|
/** |
|
* Appends all of the HTML elements to their relevant parent Elements |
|
*/ |
|
SearchPane.prototype._displayPane = function () { |
|
var container = this.dom.container; |
|
var colOpts = this.s.colOpts; |
|
var layVal = parseInt(this.c.layout.split('-')[1], 10); |
|
// Empty everything to start again |
|
$(this.dom.topRow).empty(); |
|
$(this.dom.dtP).empty(); |
|
$(this.dom.topRow).addClass(this.classes.topRow); |
|
// If there are more than 3 columns defined then make there be a smaller gap between the panes |
|
if (layVal > 3) { |
|
$(this.dom.container).addClass(this.classes.smallGap); |
|
} |
|
$(this.dom.topRow).addClass(this.classes.subRowsContainer); |
|
$(this.dom.upper).appendTo(this.dom.topRow); |
|
$(this.dom.lower).appendTo(this.dom.topRow); |
|
$(this.dom.searchCont).appendTo(this.dom.upper); |
|
$(this.dom.buttonGroup).appendTo(this.dom.lower); |
|
// If no selections have been made in the pane then disable the clear button |
|
if (this.c.dtOpts.searching === false || |
|
(colOpts.dtOpts !== undefined && |
|
colOpts.dtOpts.searching === false) || |
|
(!this.c.controls || !colOpts.controls) || |
|
(this.customPaneSettings !== null && |
|
this.customPaneSettings.dtOpts !== undefined && |
|
this.customPaneSettings.dtOpts.searching !== undefined && |
|
!this.customPaneSettings.dtOpts.searching)) { |
|
$(this.dom.searchBox).attr('disabled', 'disabled') |
|
.removeClass(this.classes.paneInputButton) |
|
.addClass(this.classes.disabledButton); |
|
} |
|
$(this.dom.searchBox).appendTo(this.dom.searchCont); |
|
// Create the contents of the searchCont div. Worth noting that this function will change when using semantic ui |
|
this._searchContSetup(); |
|
// If the clear button is allowed to show then display it |
|
if (this.c.clear && this.c.controls && colOpts.controls) { |
|
$(this.dom.clear).appendTo(this.dom.buttonGroup); |
|
} |
|
if (this.c.orderable && colOpts.orderable && this.c.controls && colOpts.controls) { |
|
$(this.dom.nameButton).appendTo(this.dom.buttonGroup); |
|
} |
|
// If the count column is hidden then don't display the ordering button for it |
|
if (!this.c.hideCount && |
|
!colOpts.hideCount && |
|
this.c.orderable && |
|
colOpts.orderable && |
|
this.c.controls && |
|
colOpts.controls) { |
|
$(this.dom.countButton).appendTo(this.dom.buttonGroup); |
|
} |
|
$(this.dom.topRow).prependTo(this.dom.container); |
|
$(container).append(this.dom.dtP); |
|
$(container).show(); |
|
}; |
|
/** |
|
* Gets the options for the row for the customPanes |
|
* @returns {object} The options for the row extended to include the options from the user. |
|
*/ |
|
SearchPane.prototype._getBonusOptions = function () { |
|
// We need to reset the thresholds as if they have a value in colOpts then that value will be used |
|
var defaultMutator = { |
|
orthogonal: { |
|
threshold: null |
|
}, |
|
threshold: null |
|
}; |
|
return $.extend(true, {}, SearchPane.defaults, defaultMutator, this.c !== undefined ? this.c : {}); |
|
}; |
|
/** |
|
* Adds the custom options to the pane |
|
* @returns {Array} Returns the array of rows which have been added to the pane |
|
*/ |
|
SearchPane.prototype._getComparisonRows = function () { |
|
var colOpts = this.s.colOpts; |
|
// Find the appropriate options depending on whether this is a pane for a specific column or a custom pane |
|
var options = colOpts.options !== undefined |
|
? colOpts.options |
|
: this.customPaneSettings !== null && this.customPaneSettings.options !== undefined |
|
? this.customPaneSettings.options |
|
: undefined; |
|
if (options === undefined) { |
|
return; |
|
} |
|
var tableVals = this.s.dt.rows({ search: 'applied' }).data().toArray(); |
|
var appRows = this.s.dt.rows({ search: 'applied' }); |
|
var tableValsTotal = this.s.dt.rows().data().toArray(); |
|
var allRows = this.s.dt.rows(); |
|
var rows = []; |
|
// Clear all of the other rows from the pane, only custom options are to be displayed when they are defined |
|
this.s.dtPane.clear(); |
|
for (var _i = 0, options_1 = options; _i < options_1.length; _i++) { |
|
var comp = options_1[_i]; |
|
// Initialise the object which is to be placed in the row |
|
var insert = comp.label !== '' ? comp.label : this.c.emptyMessage; |
|
var comparisonObj = { |
|
className: comp.className, |
|
display: insert, |
|
filter: typeof comp.value === 'function' ? comp.value : [], |
|
shown: 0, |
|
sort: insert, |
|
total: 0, |
|
type: insert |
|
}; |
|
// If a custom function is in place |
|
if (typeof comp.value === 'function') { |
|
// Count the number of times the function evaluates to true for the data currently being displayed |
|
for (var tVal = 0; tVal < tableVals.length; tVal++) { |
|
if (comp.value.call(this.s.dt, tableVals[tVal], appRows[0][tVal])) { |
|
comparisonObj.shown++; |
|
} |
|
} |
|
// Count the number of times the function evaluates to true for the original data in the Table |
|
for (var i = 0; i < tableValsTotal.length; i++) { |
|
if (comp.value.call(this.s.dt, tableValsTotal[i], allRows[0][i])) { |
|
comparisonObj.total++; |
|
} |
|
} |
|
// Update the comparisonObj |
|
if (typeof comparisonObj.filter !== 'function') { |
|
comparisonObj.filter.push(comp.filter); |
|
} |
|
} |
|
// If cascadePanes is not active or if it is and the comparisonObj should be shown then add it to the pane |
|
if (!this.c.cascadePanes || (this.c.cascadePanes && comparisonObj.shown !== 0)) { |
|
rows.push(this._addRow(comparisonObj.display, comparisonObj.filter, comparisonObj.shown, comparisonObj.total, comparisonObj.sort, comparisonObj.type, comparisonObj.className)); |
|
} |
|
} |
|
return rows; |
|
}; |
|
/** |
|
* Gets the options for the row for the customPanes |
|
* @returns {object} The options for the row extended to include the options from the user. |
|
*/ |
|
SearchPane.prototype._getOptions = function () { |
|
var table = this.s.dt; |
|
// We need to reset the thresholds as if they have a value in colOpts then that value will be used |
|
var defaultMutator = { |
|
emptyMessage: false, |
|
orthogonal: { |
|
threshold: null |
|
}, |
|
threshold: null |
|
}; |
|
return $.extend(true, {}, SearchPane.defaults, defaultMutator, table.settings()[0].aoColumns[this.s.index].searchPanes); |
|
}; |
|
/** |
|
* This method allows for changes to the panes and table to be made when a selection or a deselection occurs |
|
* @param select Denotes whether a selection has been made or not |
|
*/ |
|
SearchPane.prototype._makeSelection = function () { |
|
this.updateTable(); |
|
this.s.updating = true; |
|
this.s.dt.draw(); |
|
this.s.updating = false; |
|
}; |
|
/** |
|
* Fill the array with the values that are currently being displayed in the table |
|
* @param last boolean to indicate whether this was the last pane a selection was made in |
|
*/ |
|
SearchPane.prototype._populatePane = function (last) { |
|
if (last === void 0) { last = false; } |
|
var table = this.s.dt; |
|
this.s.rowData.arrayFilter = []; |
|
this.s.rowData.bins = {}; |
|
var settings = this.s.dt.settings()[0]; |
|
// If cascadePanes or viewTotal are active it is necessary to get the data which is currently |
|
// being displayed for their functionality. Also make sure that this was not the last pane to have a selection made |
|
if (!this.s.dt.page.info().serverSide) { |
|
var indexArray = (this.c.cascadePanes || this.c.viewTotal) && (!this.s.clearing && !last) ? |
|
table.rows({ search: 'applied' }).indexes() : |
|
table.rows().indexes(); |
|
for (var _i = 0, _a = indexArray.toArray(); _i < _a.length; _i++) { |
|
var index = _a[_i]; |
|
this._populatePaneArray(index, this.s.rowData.arrayFilter, settings); |
|
} |
|
} |
|
}; |
|
/** |
|
* Populates an array with all of the data for the table |
|
* @param rowIdx The current row index to be compared |
|
* @param arrayFilter The array that is to be populated with row Details |
|
* @param bins The bins object that is to be populated with the row counts |
|
*/ |
|
SearchPane.prototype._populatePaneArray = function (rowIdx, arrayFilter, settings, bins) { |
|
if (bins === void 0) { bins = this.s.rowData.bins; } |
|
var colOpts = this.s.colOpts; |
|
// Retrieve the rendered data from the cell using the fnGetCellData function |
|
// rather than the cell().render API method for optimisation |
|
if (typeof colOpts.orthogonal === 'string') { |
|
var rendered = settings.oApi._fnGetCellData(settings, rowIdx, this.s.index, colOpts.orthogonal); |
|
this.s.rowData.filterMap.set(rowIdx, rendered); |
|
this._addOption(rendered, rendered, rendered, rendered, arrayFilter, bins); |
|
} |
|
else { |
|
var filter = settings.oApi._fnGetCellData(settings, rowIdx, this.s.index, colOpts.orthogonal.search); |
|
// Null and empty string are to be considered the same value |
|
if (filter === null) { |
|
filter = ''; |
|
} |
|
if (typeof filter === 'string') { |
|
filter = filter.replace(/<[^>]*>/g, ''); |
|
} |
|
this.s.rowData.filterMap.set(rowIdx, filter); |
|
if (!bins[filter]) { |
|
bins[filter] = 1; |
|
this._addOption(filter, settings.oApi._fnGetCellData(settings, rowIdx, this.s.index, colOpts.orthogonal.display), settings.oApi._fnGetCellData(settings, rowIdx, this.s.index, colOpts.orthogonal.sort), settings.oApi._fnGetCellData(settings, rowIdx, this.s.index, colOpts.orthogonal.type), arrayFilter, bins); |
|
this.s.rowData.totalOptions++; |
|
} |
|
else { |
|
bins[filter]++; |
|
this.s.rowData.totalOptions++; |
|
return; |
|
} |
|
} |
|
}; |
|
/** |
|
* Reloads all of the previous selects into the panes |
|
* @param loadedFilter The loaded filters from a previous state |
|
*/ |
|
SearchPane.prototype._reloadSelect = function (loadedFilter) { |
|
// If the state was not saved don't selected any |
|
if (loadedFilter === undefined) { |
|
return; |
|
} |
|
var idx; |
|
// For each pane, check that the loadedFilter list exists and is not null, |
|
// find the id of each search item and set it to be selected. |
|
for (var i = 0; i < loadedFilter.searchPanes.panes.length; i++) { |
|
if (loadedFilter.searchPanes.panes[i].id === this.s.index) { |
|
idx = i; |
|
break; |
|
} |
|
} |
|
if (idx !== undefined) { |
|
var table = this.s.dtPane; |
|
var rows = table.rows({ order: 'index' }).data().map(function (item) { return item.filter !== null ? |
|
item.filter.toString() : |
|
null; }).toArray(); |
|
for (var _i = 0, _a = loadedFilter.searchPanes.panes[idx].selected; _i < _a.length; _i++) { |
|
var filter = _a[_i]; |
|
var id = -1; |
|
if (filter !== null) { |
|
id = rows.indexOf(filter.toString()); |
|
} |
|
if (id > -1) { |
|
this.s.serverSelecting = true; |
|
table.row(id).select(); |
|
this.s.serverSelecting = false; |
|
} |
|
} |
|
} |
|
}; |
|
/** |
|
* This method decides whether a row should contribute to the pane or not |
|
* @param filter the value that the row is to be filtered on |
|
* @param dataIndex the row index |
|
*/ |
|
SearchPane.prototype._search = function (filter, dataIndex) { |
|
var colOpts = this.s.colOpts; |
|
var table = this.s.dt; |
|
// For each item selected in the pane, check if it is available in the cell |
|
for (var _i = 0, _a = this.selections; _i < _a.length; _i++) { |
|
var colSelect = _a[_i]; |
|
if (typeof colSelect.filter === 'string') { |
|
// The filter value will not have the & in place but a &, |
|
// so we need to do a replace to make sure that they will match |
|
colSelect.filter = colSelect.filter.replaceAll('&', '&'); |
|
} |
|
// if the filter is an array then is the column present in it |
|
if (Array.isArray(filter)) { |
|
if (filter.indexOf(colSelect.filter) !== -1) { |
|
return true; |
|
} |
|
} |
|
// if the filter is a function then does it meet the criteria of that function or not |
|
else if (typeof colSelect.filter === 'function') { |
|
if (colSelect.filter.call(table, table.row(dataIndex).data(), dataIndex)) { |
|
if (colOpts.combiner === 'or') { |
|
return true; |
|
} |
|
} |
|
// If the combiner is an "and" then we need to check against all possible selections |
|
// so if it fails here then the and is not met and return false |
|
else if (colOpts.combiner === 'and') { |
|
return false; |
|
} |
|
} |
|
// otherwise if the two filter values are equal then return true |
|
// Loose type checking incase number type in column comparing to a string |
|
else if ((filter === colSelect.filter) || |
|
(!(typeof filter === 'string' && filter.length === 0) && filter == colSelect.filter) || |
|
(colSelect.filter === null && typeof filter === 'string' && filter === '')) { |
|
return true; |
|
} |
|
} |
|
// If the combiner is an and then we need to check against all possible selections |
|
// so return true here if so because it would have returned false earlier if it had failed |
|
if (colOpts.combiner === 'and') { |
|
return true; |
|
} |
|
// Otherwise it hasn't matched with anything by this point so it must be false |
|
else { |
|
return false; |
|
} |
|
}; |
|
/** |
|
* Creates the contents of the searchCont div |
|
* |
|
* NOTE This is overridden when semantic ui styling in order to integrate the search button into the text box. |
|
*/ |
|
SearchPane.prototype._searchContSetup = function () { |
|
if (this.c.controls && this.s.colOpts.controls) { |
|
$(this.dom.searchButton).appendTo(this.dom.searchLabelCont); |
|
} |
|
if (!(this.c.dtOpts.searching === false || |
|
this.s.colOpts.dtOpts.searching === false || |
|
(this.customPaneSettings !== null && |
|
this.customPaneSettings.dtOpts !== undefined && |
|
this.customPaneSettings.dtOpts.searching !== undefined && |
|
!this.customPaneSettings.dtOpts.searching))) { |
|
$(this.dom.searchLabelCont).appendTo(this.dom.searchCont); |
|
} |
|
}; |
|
/** |
|
* Adds outline to the pane when a selection has been made |
|
*/ |
|
SearchPane.prototype._searchExtras = function () { |
|
var updating = this.s.updating; |
|
this.s.updating = true; |
|
var filters = this.s.dtPane.rows({ selected: true }).data().pluck('filter').toArray(); |
|
var nullIndex = filters.indexOf(this.s.colOpts.emptyMessage !== false ? |
|
this.s.colOpts.emptyMessage : |
|
this.c.emptyMessage); |
|
var container = $(this.s.dtPane.table().container()); |
|
// If null index is found then search for empty cells as a filter. |
|
if (nullIndex > -1) { |
|
filters[nullIndex] = ''; |
|
} |
|
// If a filter has been applied then outline the respective pane, remove it when it no longer is. |
|
if (filters.length > 0) { |
|
container.addClass(this.classes.selected); |
|
} |
|
else if (filters.length === 0) { |
|
container.removeClass(this.classes.selected); |
|
} |
|
this.s.updating = updating; |
|
}; |
|
/** |
|
* Finds the ratio of the number of different options in the table to the number of rows |
|
* @param bins the number of different options in the table |
|
* @param rowCount the total number of rows in the table |
|
* @returns {number} returns the ratio |
|
*/ |
|
SearchPane.prototype._uniqueRatio = function (bins, rowCount) { |
|
if (rowCount > 0 && |
|
((this.s.rowData.totalOptions > 0 && !this.s.dt.page.info().serverSide) || |
|
(this.s.dt.page.info().serverSide && this.s.tableLength > 0))) { |
|
return bins / this.s.rowData.totalOptions; |
|
} |
|
else { |
|
return 1; |
|
} |
|
}; |
|
/** |
|
* updates the options within the pane |
|
* @param draw a flag to define whether this has been called due to a draw event or not |
|
*/ |
|
SearchPane.prototype._updateCommon = function (draw) { |
|
if (draw === void 0) { draw = false; } |
|
// Update the panes if doing a deselect. if doing a select then |
|
// update all of the panes except for the one causing the change |
|
if (!this.s.dt.page.info().serverSide && |
|
this.s.dtPane !== undefined && |
|
(!this.s.filteringActive || this.c.cascadePanes || draw === true) && |
|
(this.c.cascadePanes !== true || this.s.selectPresent !== true) && (!this.s.lastSelect || !this.s.lastCascade)) { |
|
var colOpts = this.s.colOpts; |
|
var selected = this.s.dtPane.rows({ selected: true }).data().toArray(); |
|
var scrollTop = $(this.s.dtPane.table().node()).parent()[0].scrollTop; |
|
var rowData = this.s.rowData; |
|
// Clear the pane in preparation for adding the updated search options |
|
this.s.dtPane.clear(); |
|
// If it is not a custom pane |
|
if (this.colExists) { |
|
// Only run populatePane if the data has not been collected yet |
|
if (rowData.arrayFilter.length === 0) { |
|
this._populatePane(); |
|
} |
|
// If cascadePanes is active and the table has returned to its default state then |
|
// there is a need to update certain parts ofthe rowData. |
|
else if (this.c.cascadePanes |
|
&& this.s.dt.rows().data().toArray().length === this.s.dt.rows({ search: 'applied' }).data().toArray().length) { |
|
rowData.arrayFilter = rowData.arrayOriginal; |
|
rowData.bins = rowData.binsOriginal; |
|
} |
|
// Otherwise if viewTotal or cascadePanes is active then the data from the table must be read. |
|
else if (this.c.viewTotal || this.c.cascadePanes) { |
|
this._populatePane(); |
|
} |
|
// If the viewTotal option is selected then find the totals for the table |
|
if (this.c.viewTotal) { |
|
this._detailsPane(); |
|
} |
|
else { |
|
rowData.binsTotal = rowData.bins; |
|
} |
|
if (this.c.viewTotal && !this.c.cascadePanes) { |
|
rowData.arrayFilter = rowData.arrayTotals; |
|
} |
|
var _loop_1 = function (dataP) { |
|
// If both view Total and cascadePanes have been selected and the count of the row is not 0 then add it to pane |
|
// Do this also if the viewTotal option has been selected and cascadePanes has not |
|
if (dataP && ((rowData.bins[dataP.filter] !== undefined && rowData.bins[dataP.filter] !== 0 && this_1.c.cascadePanes) |
|
|| !this_1.c.cascadePanes |
|
|| this_1.s.clearing)) { |
|
var row = this_1._addRow(dataP.display, dataP.filter, !this_1.c.viewTotal |
|
? rowData.bins[dataP.filter] |
|
: rowData.bins[dataP.filter] !== undefined |
|
? rowData.bins[dataP.filter] |
|
: 0, this_1.c.viewTotal |
|
? String(rowData.binsTotal[dataP.filter]) |
|
: rowData.bins[dataP.filter], dataP.sort, dataP.type); |
|
// Find out if the filter was selected in the previous search, if so select it and remove from array. |
|
var selectIndex = selected.findIndex(function (element) { |
|
return element.filter === dataP.filter; |
|
}); |
|
if (selectIndex !== -1) { |
|
row.select(); |
|
selected.splice(selectIndex, 1); |
|
} |
|
} |
|
}; |
|
var this_1 = this; |
|
for (var _i = 0, _a = rowData.arrayFilter; _i < _a.length; _i++) { |
|
var dataP = _a[_i]; |
|
_loop_1(dataP); |
|
} |
|
} |
|
if ((colOpts.searchPanes !== undefined && colOpts.searchPanes.options !== undefined) || |
|
colOpts.options !== undefined || |
|
(this.customPaneSettings !== null && this.customPaneSettings.options !== undefined)) { |
|
var rows = this._getComparisonRows(); |
|
var _loop_2 = function (row) { |
|
var selectIndex = selected.findIndex(function (element) { |
|
if (element.display === row.data().display) { |
|
return true; |
|
} |
|
}); |
|
if (selectIndex !== -1) { |
|
row.select(); |
|
selected.splice(selectIndex, 1); |
|
} |
|
}; |
|
for (var _b = 0, rows_1 = rows; _b < rows_1.length; _b++) { |
|
var row = rows_1[_b]; |
|
_loop_2(row); |
|
} |
|
} |
|
// Add search options which were previously selected but whos results are no |
|
// longer present in the resulting data set. |
|
for (var _c = 0, selected_1 = selected; _c < selected_1.length; _c++) { |
|
var selectedEl = selected_1[_c]; |
|
var row = this._addRow(selectedEl.display, selectedEl.filter, 0, this.c.viewTotal |
|
? selectedEl.total |
|
: 0, selectedEl.display, selectedEl.display); |
|
this.s.updating = true; |
|
row.select(); |
|
this.s.updating = false; |
|
} |
|
this.s.dtPane.draw(); |
|
this.s.dtPane.table().node().parentNode.scrollTop = scrollTop; |
|
} |
|
}; |
|
SearchPane.version = '1.1.0'; |
|
SearchPane.classes = { |
|
buttonGroup: 'dtsp-buttonGroup', |
|
buttonSub: 'dtsp-buttonSub', |
|
clear: 'dtsp-clear', |
|
clearAll: 'dtsp-clearAll', |
|
clearButton: 'clearButton', |
|
container: 'dtsp-searchPane', |
|
countButton: 'dtsp-countButton', |
|
disabledButton: 'dtsp-disabledButton', |
|
dull: 'dtsp-dull', |
|
hidden: 'dtsp-hidden', |
|
hide: 'dtsp-hide', |
|
layout: 'dtsp-', |
|
name: 'dtsp-name', |
|
nameButton: 'dtsp-nameButton', |
|
nameCont: 'dtsp-nameCont', |
|
narrow: 'dtsp-narrow', |
|
paneButton: 'dtsp-paneButton', |
|
paneInputButton: 'dtsp-paneInputButton', |
|
pill: 'dtsp-pill', |
|
search: 'dtsp-search', |
|
searchCont: 'dtsp-searchCont', |
|
searchIcon: 'dtsp-searchIcon', |
|
searchLabelCont: 'dtsp-searchButtonCont', |
|
selected: 'dtsp-selected', |
|
smallGap: 'dtsp-smallGap', |
|
subRow1: 'dtsp-subRow1', |
|
subRow2: 'dtsp-subRow2', |
|
subRowsContainer: 'dtsp-subRowsContainer', |
|
title: 'dtsp-title', |
|
topRow: 'dtsp-topRow' |
|
}; |
|
// Define SearchPanes default options |
|
SearchPane.defaults = { |
|
cascadePanes: false, |
|
clear: true, |
|
combiner: 'or', |
|
controls: true, |
|
container: function (dt) { |
|
return dt.table().container(); |
|
}, |
|
dtOpts: {}, |
|
emptyMessage: '<i>No Data</i>', |
|
hideCount: false, |
|
layout: 'columns-3', |
|
name: undefined, |
|
orderable: true, |
|
orthogonal: { |
|
display: 'display', |
|
filter: 'filter', |
|
hideCount: false, |
|
search: 'filter', |
|
show: undefined, |
|
sort: 'sort', |
|
threshold: 0.6, |
|
type: 'type' |
|
}, |
|
preSelect: [], |
|
threshold: 0.6, |
|
viewTotal: false |
|
}; |
|
return SearchPane; |
|
}()); |
|
|
|
var $$1; |
|
var DataTable$1; |
|
function setJQuery$1(jq) { |
|
$$1 = jq; |
|
DataTable$1 = jq.fn.dataTable; |
|
} |
|
var SearchPanes = /** @class */ (function () { |
|
function SearchPanes(paneSettings, opts, fromInit) { |
|
var _this = this; |
|
if (fromInit === void 0) { fromInit = false; } |
|
this.regenerating = false; |
|
// Check that the required version of DataTables is included |
|
if (!DataTable$1 || !DataTable$1.versionCheck || !DataTable$1.versionCheck('1.10.0')) { |
|
throw new Error('SearchPane requires DataTables 1.10 or newer'); |
|
} |
|
// Check that Select is included |
|
if (!DataTable$1.select) { |
|
throw new Error('SearchPane requires Select'); |
|
} |
|
var table = new DataTable$1.Api(paneSettings); |
|
this.classes = $$1.extend(true, {}, SearchPanes.classes); |
|
// Get options from user |
|
this.c = $$1.extend(true, {}, SearchPanes.defaults, opts); |
|
// Add extra elements to DOM object including clear |
|
this.dom = { |
|
clearAll: $$1('<button type="button">Clear All</button>').addClass(this.classes.clearAll), |
|
container: $$1('<div/>').addClass(this.classes.panes).text(table.i18n('searchPanes.loadMessage', 'Loading Search Panes...')), |
|
emptyMessage: $$1('<div/>').addClass(this.classes.emptyMessage), |
|
options: $$1('<div/>').addClass(this.classes.container), |
|
panes: $$1('<div/>').addClass(this.classes.container), |
|
title: $$1('<div/>').addClass(this.classes.title), |
|
titleRow: $$1('<div/>').addClass(this.classes.titleRow), |
|
wrapper: $$1('<div/>') |
|
}; |
|
this.s = { |
|
colOpts: [], |
|
dt: table, |
|
filterCount: 0, |
|
filterPane: -1, |
|
page: 0, |
|
panes: [], |
|
selectionList: [], |
|
serverData: {}, |
|
stateRead: false, |
|
updating: false |
|
}; |
|
if (table.settings()[0]._searchPanes !== undefined) { |
|
return; |
|
} |
|
this._getState(); |
|
if (this.s.dt.page.info().serverSide) { |
|
table.on('preXhr.dt', function (e, settings, data) { |
|
if (data.searchPanes === undefined) { |
|
data.searchPanes = {}; |
|
} |
|
for (var _i = 0, _a = _this.s.selectionList; _i < _a.length; _i++) { |
|
var selection = _a[_i]; |
|
var src = _this.s.dt.column(selection.index).dataSrc(); |
|
if (data.searchPanes[src] === undefined) { |
|
data.searchPanes[src] = {}; |
|
} |
|
for (var i = 0; i < selection.rows.length; i++) { |
|
data.searchPanes[src][i] = selection.rows[i].filter; |
|
} |
|
} |
|
}); |
|
} |
|
// We are using the xhr event to rebuild the panes if required due to viewTotal being enabled |
|
// If viewTotal is not enabled then we simply update the data from the server |
|
table.on('xhr', function (e, settings, json, xhr) { |
|
if (json && json.searchPanes && json.searchPanes.options) { |
|
_this.s.serverData = json; |
|
_this.s.serverData.tableLength = json.recordsTotal; |
|
_this._serverTotals(); |
|
} |
|
}); |
|
table.settings()[0]._searchPanes = this; |
|
this.dom.clearAll.text(table.i18n('searchPanes.clearMessage', 'Clear All')); |
|
if (this.s.dt.settings()[0]._bInitComplete || fromInit) { |
|
this._paneDeclare(table, paneSettings, opts); |
|
} |
|
else { |
|
table.one('preInit.dt', function (settings) { |
|
_this._paneDeclare(table, paneSettings, opts); |
|
}); |
|
} |
|
return this; |
|
} |
|
/** |
|
* Clear the selections of all of the panes |
|
*/ |
|
SearchPanes.prototype.clearSelections = function () { |
|
// Load in all of the searchBoxes in the documents |
|
var searches = this.dom.container.find(this.classes.search); |
|
// For each searchBox set the input text to be empty and then trigger |
|
// an input on them so that they no longer filter the panes |
|
searches.each(function () { |
|
$$1(this).val(''); |
|
$$1(this).trigger('input'); |
|
}); |
|
var returnArray = []; |
|
// For every pane, clear the selections in the pane |
|
for (var _i = 0, _a = this.s.panes; _i < _a.length; _i++) { |
|
var pane = _a[_i]; |
|
if (pane.s.dtPane !== undefined) { |
|
returnArray.push(pane.clearPane()); |
|
} |
|
} |
|
this.s.dt.draw(); |
|
return returnArray; |
|
}; |
|
/** |
|
* returns the container node for the searchPanes |
|
*/ |
|
SearchPanes.prototype.getNode = function () { |
|
return this.dom.container; |
|
}; |
|
/** |
|
* rebuilds all of the panes |
|
*/ |
|
SearchPanes.prototype.rebuild = function (targetIdx, maintainSelection) { |
|
if (targetIdx === void 0) { targetIdx = false; } |
|
if (maintainSelection === void 0) { maintainSelection = false; } |
|
$$1(this.dom.emptyMessage).remove(); |
|
// As a rebuild from scratch is required, empty the searchpanes container. |
|
var returnArray = []; |
|
// Rebuild each pane individually, if a specific pane has been selected then only rebuild that one |
|
if (targetIdx === false) { |
|
$$1(this.dom.panes).empty(); |
|
} |
|
for (var _i = 0, _a = this.s.panes; _i < _a.length; _i++) { |
|
var pane = _a[_i]; |
|
if (targetIdx !== false && pane.s.index !== targetIdx) { |
|
continue; |
|
} |
|
pane.clearData(); |
|
returnArray.push( |
|
// Pass a boolean to say whether this is the last choice made for maintaining selections when rebuilding |
|
pane.rebuildPane(this.s.selectionList[this.s.selectionList.length - 1] !== undefined ? |
|
pane.s.index === this.s.selectionList[this.s.selectionList.length - 1].index : |
|
false, this.s.dt.page.info().serverSide ? |
|
this.s.serverData : |
|
undefined, null, maintainSelection)); |
|
$$1(this.dom.panes).append(pane.dom.container); |
|
} |
|
// Only need to trigger a search if it is not server side processing |
|
if (!this.s.dt.page.info().serverSide) { |
|
this.s.dt.draw(); |
|
} |
|
if (this.c.cascadePanes || this.c.viewTotal) { |
|
this.redrawPanes(true); |
|
} |
|
else { |
|
this._updateSelection(); |
|
} |
|
// Attach panes, clear buttons, and title bar to the document |
|
this._updateFilterCount(); |
|
this._attachPaneContainer(); |
|
this.s.dt.draw(); |
|
// If a single pane has been rebuilt then return only that pane |
|
if (returnArray.length === 1) { |
|
return returnArray[0]; |
|
} |
|
// Otherwise return all of the panes that have been rebuilt |
|
else { |
|
return returnArray; |
|
} |
|
}; |
|
/** |
|
* Redraws all of the panes |
|
*/ |
|
SearchPanes.prototype.redrawPanes = function (rebuild) { |
|
if (rebuild === void 0) { rebuild = false; } |
|
var table = this.s.dt; |
|
// Only do this if the redraw isn't being triggered by the panes updating themselves |
|
if (!this.s.updating && !this.s.dt.page.info().serverSide) { |
|
var filterActive = true; |
|
var filterPane = this.s.filterPane; |
|
// If the number of rows currently visible is equal to the number of rows in the table |
|
// then there can't be any filtering taking place |
|
if (table.rows({ search: 'applied' }).data().toArray().length === table.rows().data().toArray().length) { |
|
filterActive = false; |
|
} |
|
// Otherwise if viewTotal is active then it is necessary to determine which panes a select is present in. |
|
// If there is only one pane with a selection present then it should not show the filtered message as |
|
// more selections may be made in that pane. |
|
else if (this.c.viewTotal) { |
|
for (var _i = 0, _a = this.s.panes; _i < _a.length; _i++) { |
|
var pane = _a[_i]; |
|
if (pane.s.dtPane !== undefined) { |
|
var selectLength = pane.s.dtPane.rows({ selected: true }).data().toArray().length; |
|
if (selectLength === 0) { |
|
for (var _b = 0, _c = this.s.selectionList; _b < _c.length; _b++) { |
|
var selection = _c[_b]; |
|
if (selection.index === pane.s.index && selection.rows.length !== 0) { |
|
selectLength = selection.rows.length; |
|
} |
|
} |
|
} |
|
// If filterPane === -1 then a pane with a selection has not been found yet, so set filterPane to that panes index |
|
if (selectLength > 0 && filterPane === -1) { |
|
filterPane = pane.s.index; |
|
} |
|
// Then if another pane is found with a selection then set filterPane to null to |
|
// show that multiple panes have selections present |
|
else if (selectLength > 0) { |
|
filterPane = null; |
|
} |
|
} |
|
} |
|
} |
|
var deselectIdx = void 0; |
|
var newSelectionList = []; |
|
// Don't run this if it is due to the panes regenerating |
|
if (!this.regenerating) { |
|
for (var _d = 0, _e = this.s.panes; _d < _e.length; _d++) { |
|
var pane = _e[_d]; |
|
// Identify the pane where a selection or deselection has been made and add it to the list. |
|
if (pane.s.selectPresent) { |
|
this.s.selectionList.push({ index: pane.s.index, rows: pane.s.dtPane.rows({ selected: true }).data().toArray(), protect: false }); |
|
table.state.save(); |
|
break; |
|
} |
|
else if (pane.s.deselect) { |
|
deselectIdx = pane.s.index; |
|
var selectedData = pane.s.dtPane.rows({ selected: true }).data().toArray(); |
|
if (selectedData.length > 0) { |
|
this.s.selectionList.push({ index: pane.s.index, rows: selectedData, protect: true }); |
|
} |
|
} |
|
} |
|
if (this.s.selectionList.length > 0) { |
|
var last = this.s.selectionList[this.s.selectionList.length - 1].index; |
|
for (var _f = 0, _g = this.s.panes; _f < _g.length; _f++) { |
|
var pane = _g[_f]; |
|
pane.s.lastSelect = (pane.s.index === last); |
|
} |
|
} |
|
// Remove selections from the list from the pane where a deselect has taken place |
|
for (var i = 0; i < this.s.selectionList.length; i++) { |
|
if (this.s.selectionList[i].index !== deselectIdx || this.s.selectionList[i].protect === true) { |
|
var further = false; |
|
// Find out if this selection is the last one in the list for that pane |
|
for (var j = i + 1; j < this.s.selectionList.length; j++) { |
|
if (this.s.selectionList[j].index === this.s.selectionList[i].index) { |
|
further = true; |
|
} |
|
} |
|
// If there are no selections for this pane in the list then just push this one |
|
if (!further) { |
|
newSelectionList.push(this.s.selectionList[i]); |
|
this.s.selectionList[i].protect = false; |
|
} |
|
} |
|
} |
|
var solePane = -1; |
|
if (newSelectionList.length === 1) { |
|
solePane = newSelectionList[0].index; |
|
} |
|
// Update all of the panes to reflect the current state of the filters |
|
for (var _h = 0, _j = this.s.panes; _h < _j.length; _h++) { |
|
var pane = _j[_h]; |
|
if (pane.s.dtPane !== undefined) { |
|
var tempFilter = true; |
|
pane.s.filteringActive = true; |
|
if ((filterPane !== -1 && filterPane !== null && filterPane === pane.s.index) || |
|
filterActive === false || |
|
pane.s.index === solePane) { |
|
tempFilter = false; |
|
pane.s.filteringActive = false; |
|
} |
|
pane.updatePane(!tempFilter ? false : filterActive); |
|
} |
|
} |
|
// Update the label that shows how many filters are in place |
|
this._updateFilterCount(); |
|
// If the length of the selections are different then some of them have been removed and a deselect has occured |
|
if (newSelectionList.length > 0 && (newSelectionList.length < this.s.selectionList.length || rebuild)) { |
|
this._cascadeRegen(newSelectionList); |
|
var last = newSelectionList[newSelectionList.length - 1].index; |
|
for (var _k = 0, _l = this.s.panes; _k < _l.length; _k++) { |
|
var pane = _l[_k]; |
|
pane.s.lastSelect = (pane.s.index === last); |
|
} |
|
} |
|
else if (newSelectionList.length > 0) { |
|
// Update all of the other panes as you would just making a normal selection |
|
for (var _m = 0, _o = this.s.panes; _m < _o.length; _m++) { |
|
var paneUpdate = _o[_m]; |
|
if (paneUpdate.s.dtPane !== undefined) { |
|
var tempFilter = true; |
|
paneUpdate.s.filteringActive = true; |
|
if ((filterPane !== -1 && filterPane !== null && filterPane === paneUpdate.s.index) || filterActive === false) { |
|
tempFilter = false; |
|
paneUpdate.s.filteringActive = false; |
|
} |
|
paneUpdate.updatePane(!tempFilter ? tempFilter : filterActive); |
|
} |
|
} |
|
} |
|
} |
|
else { |
|
var solePane = -1; |
|
if (newSelectionList.length === 1) { |
|
solePane = newSelectionList[0].index; |
|
} |
|
for (var _p = 0, _q = this.s.panes; _p < _q.length; _p++) { |
|
var pane = _q[_p]; |
|
if (pane.s.dtPane !== undefined) { |
|
var tempFilter = true; |
|
pane.s.filteringActive = true; |
|
if ((filterPane !== -1 && filterPane !== null && filterPane === pane.s.index) || |
|
filterActive === false || |
|
pane.s.index === solePane) { |
|
tempFilter = false; |
|
pane.s.filteringActive = false; |
|
} |
|
pane.updatePane(!tempFilter ? tempFilter : filterActive); |
|
} |
|
} |
|
// Update the label that shows how many filters are in place |
|
this._updateFilterCount(); |
|
} |
|
if (!filterActive) { |
|
this.s.selectionList = []; |
|
} |
|
} |
|
}; |
|
/** |
|
* Attach the panes, buttons and title to the document |
|
*/ |
|
SearchPanes.prototype._attach = function () { |
|
var _this = this; |
|
$$1(this.dom.container).removeClass(this.classes.hide); |
|
$$1(this.dom.titleRow).removeClass(this.classes.hide); |
|
$$1(this.dom.titleRow).remove(); |
|
$$1(this.dom.title).appendTo(this.dom.titleRow); |
|
// If the clear button is permitted attach it |
|
if (this.c.clear) { |
|
$$1(this.dom.clearAll).appendTo(this.dom.titleRow); |
|
$$1(this.dom.clearAll).on('click.dtsps', function () { |
|
_this.clearSelections(); |
|
}); |
|
} |
|
$$1(this.dom.titleRow).appendTo(this.dom.container); |
|
// Attach the container for each individual pane to the overall container |
|
for (var _i = 0, _a = this.s.panes; _i < _a.length; _i++) { |
|
var pane = _a[_i]; |
|
$$1(pane.dom.container).appendTo(this.dom.panes); |
|
} |
|
// Attach everything to the document |
|
$$1(this.dom.panes).appendTo(this.dom.container); |
|
if ($$1('div.' + this.classes.container).length === 0) { |
|
$$1(this.dom.container).prependTo(this.s.dt); |
|
} |
|
return this.dom.container; |
|
}; |
|
/** |
|
* Attach the top row containing the filter count and clear all button |
|
*/ |
|
SearchPanes.prototype._attachExtras = function () { |
|
$$1(this.dom.container).removeClass(this.classes.hide); |
|
$$1(this.dom.titleRow).removeClass(this.classes.hide); |
|
$$1(this.dom.titleRow).remove(); |
|
$$1(this.dom.title).appendTo(this.dom.titleRow); |
|
// If the clear button is permitted attach it |
|
if (this.c.clear) { |
|
$$1(this.dom.clearAll).appendTo(this.dom.titleRow); |
|
} |
|
$$1(this.dom.titleRow).appendTo(this.dom.container); |
|
return this.dom.container; |
|
}; |
|
/** |
|
* If there are no panes to display then this method is called to either |
|
* display a message in their place or hide them completely. |
|
*/ |
|
SearchPanes.prototype._attachMessage = function () { |
|
// Create a message to display on the screen |
|
var message; |
|
try { |
|
message = this.s.dt.i18n('searchPanes.emptyPanes', 'No SearchPanes'); |
|
} |
|
catch (error) { |
|
message = null; |
|
} |
|
// If the message is an empty string then searchPanes.emptyPanes is undefined, |
|
// therefore the pane container should be removed from the display |
|
if (message === null) { |
|
$$1(this.dom.container).addClass(this.classes.hide); |
|
$$1(this.dom.titleRow).removeClass(this.classes.hide); |
|
return; |
|
} |
|
else { |
|
$$1(this.dom.container).removeClass(this.classes.hide); |
|
$$1(this.dom.titleRow).addClass(this.classes.hide); |
|
} |
|
// Otherwise display the message |
|
$$1(this.dom.emptyMessage).text(message); |
|
this.dom.emptyMessage.appendTo(this.dom.container); |
|
return this.dom.container; |
|
}; |
|
/** |
|
* Attaches the panes to the document and displays a message or hides if there are none |
|
*/ |
|
SearchPanes.prototype._attachPaneContainer = function () { |
|
// If a pane is to be displayed then attach the normal pane output |
|
for (var _i = 0, _a = this.s.panes; _i < _a.length; _i++) { |
|
var pane = _a[_i]; |
|
if (pane.s.displayed === true) { |
|
return this._attach(); |
|
} |
|
} |
|
// Otherwise attach the custom message or remove the container from the display |
|
return this._attachMessage(); |
|
}; |
|
/** |
|
* Prepares the panes for selections to be made when cascade is active and a deselect has occured |
|
* @param newSelectionList the list of selections which are to be made |
|
*/ |
|
SearchPanes.prototype._cascadeRegen = function (newSelectionList) { |
|
// Set this to true so that the actions taken do not cause this to run until it is finished |
|
this.regenerating = true; |
|
// If only one pane has been selected then take note of its index |
|
var solePane = -1; |
|
if (newSelectionList.length === 1) { |
|
solePane = newSelectionList[0].index; |
|
} |
|
// Let the pane know that a cascadeRegen is taking place to avoid unexpected behaviour |
|
// and clear all of the previous selections in the pane |
|
for (var _i = 0, _a = this.s.panes; _i < _a.length; _i++) { |
|
var pane = _a[_i]; |
|
pane.setCascadeRegen(true); |
|
pane.setClear(true); |
|
// If this is the same as the pane with the only selection then pass it as a parameter into clearPane |
|
if ((pane.s.dtPane !== undefined && pane.s.index === solePane) || pane.s.dtPane !== undefined) { |
|
pane.clearPane(); |
|
} |
|
pane.setClear(false); |
|
} |
|
// Remake Selections |
|
this._makeCascadeSelections(newSelectionList); |
|
// Set the selection list property to be the list without the selections from the deselect pane |
|
this.s.selectionList = newSelectionList; |
|
// The regeneration of selections is over so set it back to false |
|
for (var _b = 0, _c = this.s.panes; _b < _c.length; _b++) { |
|
var pane = _c[_b]; |
|
pane.setCascadeRegen(false); |
|
} |
|
this.regenerating = false; |
|
}; |
|
/** |
|
* Attaches the message to the document but does not add any panes |
|
*/ |
|
SearchPanes.prototype._checkMessage = function () { |
|
// If a pane is to be displayed then attach the normal pane output |
|
for (var _i = 0, _a = this.s.panes; _i < _a.length; _i++) { |
|
var pane = _a[_i]; |
|
if (pane.s.displayed === true) { |
|
return; |
|
} |
|
} |
|
// Otherwise attach the custom message or remove the container from the display |
|
return this._attachMessage(); |
|
}; |
|
/** |
|
* Gets the selection list from the previous state and stores it in the selectionList Property |
|
*/ |
|
SearchPanes.prototype._getState = function () { |
|
var loadedFilter = this.s.dt.state.loaded(); |
|
if (loadedFilter && loadedFilter.searchPanes && loadedFilter.searchPanes.selectionList !== undefined) { |
|
this.s.selectionList = loadedFilter.searchPanes.selectionList; |
|
} |
|
}; |
|
/** |
|
* Makes all of the selections when cascade is active |
|
* @param newSelectionList the list of selections to be made, in the order they were originally selected |
|
*/ |
|
SearchPanes.prototype._makeCascadeSelections = function (newSelectionList) { |
|
// make selections in the order they were made previously, excluding those from the pane where a deselect was made |
|
for (var i = 0; i < newSelectionList.length; i++) { |
|
var _loop_1 = function (pane) { |
|
if (pane.s.index === newSelectionList[i].index && pane.s.dtPane !== undefined) { |
|
// When regenerating the cascade selections we need this flag so that the panes are only ignored if it |
|
// is the last selection and the pane for that selection |
|
if (i === newSelectionList.length - 1) { |
|
pane.s.lastCascade = true; |
|
} |
|
// if there are any selections currently in the pane then deselect them as we are about to make our new selections |
|
if (pane.s.dtPane.rows({ selected: true }).data().toArray().length > 0 && pane.s.dtPane !== undefined) { |
|
pane.setClear(true); |
|
pane.clearPane(); |
|
pane.setClear(false); |
|
} |
|
var _loop_2 = function (row) { |
|
pane.s.dtPane.rows().every(function (rowIdx) { |
|
if (pane.s.dtPane.row(rowIdx).data() !== undefined && |
|
row !== undefined && |
|
pane.s.dtPane.row(rowIdx).data().filter === row.filter) { |
|
pane.s.dtPane.row(rowIdx).select(); |
|
} |
|
}); |
|
}; |
|
// select every row in the pane that was selected previously |
|
for (var _i = 0, _a = newSelectionList[i].rows; _i < _a.length; _i++) { |
|
var row = _a[_i]; |
|
_loop_2(row); |
|
} |
|
// Update the label that shows how many filters are in place |
|
this_1._updateFilterCount(); |
|
pane.s.lastCascade = false; |
|
} |
|
}; |
|
var this_1 = this; |
|
// As the selections may have been made across the panes in a different order to the pane index we must identify |
|
// which pane has the index of the selection. This is also important for colreorder etc |
|
for (var _i = 0, _a = this.s.panes; _i < _a.length; _i++) { |
|
var pane = _a[_i]; |
|
_loop_1(pane); |
|
} |
|
} |
|
// Make sure that the state is saved after all of these selections |
|
this.s.dt.state.save(); |
|
}; |
|
/** |
|
* Declares the instances of individual searchpanes dependant on the number of columns. |
|
* It is necessary to run this once preInit has completed otherwise no panes will be |
|
* created as the column count will be 0. |
|
* @param table the DataTable api for the parent table |
|
* @param paneSettings the settings passed into the constructor |
|
* @param opts the options passed into the constructor |
|
*/ |
|
SearchPanes.prototype._paneDeclare = function (table, paneSettings, opts) { |
|
var _this = this; |
|
// Create Panes |
|
table |
|
.columns(this.c.columns.length > 0 ? this.c.columns : undefined) |
|
.eq(0) |
|
.each(function (idx) { |
|
_this.s.panes.push(new SearchPane(paneSettings, opts, idx, _this.c.layout, _this.dom.panes)); |
|
}); |
|
// If there is any extra custom panes defined then create panes for them too |
|
var rowLength = table.columns().eq(0).toArray().length; |
|
var paneLength = this.c.panes.length; |
|
for (var i = 0; i < paneLength; i++) { |
|
var id = rowLength + i; |
|
this.s.panes.push(new SearchPane(paneSettings, opts, id, this.c.layout, this.dom.panes, this.c.panes[i])); |
|
} |
|
// If a custom ordering is being used |
|
if (this.c.order.length > 0) { |
|
// Make a new Array of panes based upon the order |
|
var newPanes = this.c.order.map(function (name, index, values) { |
|
return _this._findPane(name); |
|
}); |
|
// Remove the old panes from the dom |
|
this.dom.panes.empty(); |
|
this.s.panes = newPanes; |
|
// Append the panes in the correct order |
|
for (var _i = 0, _a = this.s.panes; _i < _a.length; _i++) { |
|
var pane = _a[_i]; |
|
this.dom.panes.append(pane.dom.container); |
|
} |
|
} |
|
// If this internal property is true then the DataTable has been initialised already |
|
if (this.s.dt.settings()[0]._bInitComplete) { |
|
this._startup(table); |
|
} |
|
else { |
|
// Otherwise add the paneStartup function to the list of functions that are to be run when the table is initialised |
|
// This will garauntee that the panes are initialised before the init event and init Complete callback is fired |
|
this.s.dt.settings()[0].aoInitComplete.push({ fn: function () { |
|
_this._startup(table); |
|
} }); |
|
} |
|
}; |
|
/** |
|
* Finds a pane based upon the name of that pane |
|
* @param name string representing the name of the pane |
|
* @returns SearchPane The pane which has that name |
|
*/ |
|
SearchPanes.prototype._findPane = function (name) { |
|
for (var _i = 0, _a = this.s.panes; _i < _a.length; _i++) { |
|
var pane = _a[_i]; |
|
if (name === pane.s.name) { |
|
return pane; |
|
} |
|
} |
|
}; |
|
/** |
|
* Works out which panes to update when data is recieved from the server and viewTotal is active |
|
*/ |
|
SearchPanes.prototype._serverTotals = function () { |
|
var selectPresent = false; |
|
var deselectPresent = false; |
|
var table = this.s.dt; |
|
for (var _i = 0, _a = this.s.panes; _i < _a.length; _i++) { |
|
var pane = _a[_i]; |
|
// Identify the pane where a selection or deselection has been made and add it to the list. |
|
if (pane.s.selectPresent) { |
|
this.s.selectionList.push({ index: pane.s.index, rows: pane.s.dtPane.rows({ selected: true }).data().toArray(), protect: false }); |
|
table.state.save(); |
|
pane.s.selectPresent = false; |
|
selectPresent = true; |
|
break; |
|
} |
|
else if (pane.s.deselect) { |
|
var selectedData = pane.s.dtPane.rows({ selected: true }).data().toArray(); |
|
if (selectedData.length > 0) { |
|
this.s.selectionList.push({ index: pane.s.index, rows: selectedData, protect: true }); |
|
} |
|
selectPresent = true; |
|
deselectPresent = true; |
|
} |
|
} |
|
// Build an updated list based on any selections or deselections added |
|
if (!selectPresent) { |
|
this.s.selectionList = []; |
|
} |
|
else { |
|
var newSelectionList = []; |
|
for (var i = 0; i < this.s.selectionList.length; i++) { |
|
var further = false; |
|
// Find out if this selection is the last one in the list for that pane |
|
for (var j = i + 1; j < this.s.selectionList.length; j++) { |
|
if (this.s.selectionList[j].index === this.s.selectionList[i].index) { |
|
further = true; |
|
} |
|
} |
|
// If there are no selections for this pane in the list then just push this one |
|
if (!further) { |
|
var push = false; |
|
for (var _b = 0, _c = this.s.panes; _b < _c.length; _b++) { |
|
var pane = _c[_b]; |
|
if (pane.s.index === this.s.selectionList[i].index && |
|
pane.s.dtPane.rows({ selected: true }).data().toArray().length > 0) { |
|
push = true; |
|
} |
|
} |
|
if (push) { |
|
newSelectionList.push(this.s.selectionList[i]); |
|
} |
|
} |
|
} |
|
this.s.selectionList = newSelectionList; |
|
} |
|
var initIdx = -1; |
|
// If there has been a deselect and only one pane has a selection then update everything |
|
if (deselectPresent && this.s.selectionList.length === 1) { |
|
for (var _d = 0, _e = this.s.panes; _d < _e.length; _d++) { |
|
var pane = _e[_d]; |
|
pane.s.lastSelect = false; |
|
pane.s.deselect = false; |
|
if (pane.s.dtPane !== undefined && pane.s.dtPane.rows({ selected: true }).data().toArray().length > 0) { |
|
initIdx = pane.s.index; |
|
} |
|
} |
|
} |
|
// Otherwise if there are more 1 selections then find the last one and set it to not update that pane |
|
else if (this.s.selectionList.length > 0) { |
|
var last = this.s.selectionList[this.s.selectionList.length - 1].index; |
|
for (var _f = 0, _g = this.s.panes; _f < _g.length; _f++) { |
|
var pane = _g[_f]; |
|
pane.s.lastSelect = (pane.s.index === last); |
|
pane.s.deselect = false; |
|
} |
|
} |
|
// Otherwise if there are no selections then find where that took place and do not update to maintain scrolling |
|
else if (this.s.selectionList.length === 0) { |
|
for (var _h = 0, _j = this.s.panes; _h < _j.length; _h++) { |
|
var pane = _j[_h]; |
|
// pane.s.lastSelect = (pane.s.deselect === true); |
|
pane.s.lastSelect = false; |
|
pane.s.deselect = false; |
|
} |
|
} |
|
$$1(this.dom.panes).empty(); |
|
// Rebuild the desired panes |
|
for (var _k = 0, _l = this.s.panes; _k < _l.length; _k++) { |
|
var pane = _l[_k]; |
|
if (!pane.s.lastSelect) { |
|
pane.rebuildPane(undefined, this.s.dt.page.info().serverSide ? this.s.serverData : undefined, pane.s.index === initIdx ? true : null, true); |
|
} |
|
else { |
|
pane._setListeners(); |
|
} |
|
// append all of the panes and enable select |
|
$$1(this.dom.panes).append(pane.dom.container); |
|
if (pane.s.dtPane !== undefined) { |
|
$$1(pane.s.dtPane.table().node()).parent()[0].scrollTop = pane.s.scrollTop; |
|
$$1.fn.dataTable.select.init(pane.s.dtPane); |
|
} |
|
} |
|
// Only need to trigger a search if it is not server side processing |
|
if (!this.s.dt.page.info().serverSide) { |
|
this.s.dt.draw(); |
|
} |
|
}; |
|
/** |
|
* Initialises the tables previous/preset selections and initialises callbacks for events |
|
* @param table the parent table for which the searchPanes are being created |
|
*/ |
|
SearchPanes.prototype._startup = function (table) { |
|
var _this = this; |
|
$$1(this.dom.container).text(''); |
|
// Attach clear button and title bar to the document |
|
this._attachExtras(); |
|
$$1(this.dom.container).append(this.dom.panes); |
|
$$1(this.dom.panes).empty(); |
|
var loadedFilter = this.s.dt.state.loaded(); |
|
if (this.c.viewTotal && !this.c.cascadePanes) { |
|
if (loadedFilter !== null && |
|
loadedFilter !== undefined && |
|
loadedFilter.searchPanes !== undefined && |
|
loadedFilter.searchPanes.panes !== undefined) { |
|
var filterActive = false; |
|
for (var _i = 0, _a = loadedFilter.searchPanes.panes; _i < _a.length; _i++) { |
|
var pane = _a[_i]; |
|
if (pane.selected.length > 0) { |
|
filterActive = true; |
|
break; |
|
} |
|
} |
|
if (filterActive) { |
|
for (var _b = 0, _c = this.s.panes; _b < _c.length; _b++) { |
|
var pane = _c[_b]; |
|
pane.s.showFiltered = true; |
|
} |
|
} |
|
} |
|
} |
|
for (var _d = 0, _e = this.s.panes; _d < _e.length; _d++) { |
|
var pane = _e[_d]; |
|
pane.rebuildPane(undefined, Object.keys(this.s.serverData).length > 0 ? this.s.serverData : undefined); |
|
$$1(this.dom.panes).append(pane.dom.container); |
|
} |
|
// Only need to trigger a search if it is not server side processing |
|
if (!this.s.dt.page.info().serverSide) { |
|
this.s.dt.draw(); |
|
} |
|
// Reset the paging if that has been saved in the state |
|
if (!this.s.stateRead && loadedFilter !== null && loadedFilter !== undefined) { |
|
this.s.dt.page((loadedFilter.start / this.s.dt.page.len())); |
|
this.s.dt.draw('page'); |
|
} |
|
this.s.stateRead = true; |
|
if (this.c.viewTotal && !this.c.cascadePanes) { |
|
for (var _f = 0, _g = this.s.panes; _f < _g.length; _f++) { |
|
var pane = _g[_f]; |
|
pane.updatePane(); |
|
} |
|
} |
|
this._updateFilterCount(); |
|
this._checkMessage(); |
|
// When a draw is called on the DataTable, update all of the panes incase the data in the DataTable has changed |
|
table.on('preDraw.dtsps', function () { |
|
_this._updateFilterCount(); |
|
if ((_this.c.cascadePanes || _this.c.viewTotal) && !_this.s.dt.page.info().serverSide) { |
|
_this.redrawPanes(); |
|
} |
|
else { |
|
_this._updateSelection(); |
|
} |
|
_this.s.filterPane = -1; |
|
}); |
|
// Whenever a state save occurs store the selection list in the state object |
|
this.s.dt.on('stateSaveParams.dtsp', function (e, settings, data) { |
|
if (data.searchPanes === undefined) { |
|
data.searchPanes = {}; |
|
} |
|
data.searchPanes.selectionList = _this.s.selectionList; |
|
}); |
|
if (this.s.dt.page.info().serverSide) { |
|
table.off('page'); |
|
table.on('page', function () { |
|
_this.s.page = _this.s.dt.page(); |
|
}); |
|
table.off('preXhr.dt'); |
|
table.on('preXhr.dt', function (e, settings, data) { |
|
if (data.searchPanes === undefined) { |
|
data.searchPanes = {}; |
|
} |
|
// Count how many filters are being applied |
|
var filterCount = 0; |
|
for (var _i = 0, _a = _this.s.panes; _i < _a.length; _i++) { |
|
var pane = _a[_i]; |
|
var src = _this.s.dt.column(pane.s.index).dataSrc(); |
|
if (data.searchPanes[src] === undefined) { |
|
data.searchPanes[src] = {}; |
|
} |
|
if (pane.s.dtPane !== undefined) { |
|
var rowData = pane.s.dtPane.rows({ selected: true }).data().toArray(); |
|
for (var i = 0; i < rowData.length; i++) { |
|
data.searchPanes[src][i] = rowData[i].filter; |
|
filterCount++; |
|
} |
|
} |
|
} |
|
if (_this.c.viewTotal) { |
|
_this._prepViewTotal(); |
|
} |
|
// If there is a filter to be applied, then we need to read from the start of the result set |
|
// and set the paging to 0. This matches the behaviour of client side processing |
|
if (filterCount > 0) { |
|
// If the number of filters has changed we need to read from the start of the result set and reset the paging |
|
if (filterCount !== _this.s.filterCount) { |
|
data.start = 0; |
|
_this.s.page = 0; |
|
} |
|
// Otherwise it is a paging request and we need to read from whatever the paging has been set to |
|
else { |
|
data.start = _this.s.page * _this.s.dt.page.len(); |
|
} |
|
_this.s.dt.page(_this.s.page); |
|
_this.s.filterCount = filterCount; |
|
} |
|
}); |
|
} |
|
else { |
|
table.on('preXhr.dt', function (e, settings, data) { |
|
for (var _i = 0, _a = _this.s.panes; _i < _a.length; _i++) { |
|
var pane = _a[_i]; |
|
pane.clearData(); |
|
} |
|
}); |
|
} |
|
// If the data is reloaded from the server then it is possible that it has changed completely, |
|
// so we need to rebuild the panes |
|
this.s.dt.on('xhr', function (e, settings, json, xhr) { |
|
var processing = false; |
|
if (!_this.s.dt.page.info().serverSide) { |
|
_this.s.dt.one('preDraw', function () { |
|
if (processing) { |
|
return; |
|
} |
|
var page = _this.s.dt.page(); |
|
processing = true; |
|
$$1(_this.dom.panes).empty(); |
|
for (var _i = 0, _a = _this.s.panes; _i < _a.length; _i++) { |
|
var pane = _a[_i]; |
|
pane.clearData(); // Clears all of the bins and will mean that the data has to be re-read |
|
// Pass a boolean to say whether this is the last choice made for maintaining selections when rebuilding |
|
pane.rebuildPane(_this.s.selectionList[_this.s.selectionList.length - 1] !== undefined ? |
|
pane.s.index === _this.s.selectionList[_this.s.selectionList.length - 1].index : |
|
false, undefined, undefined, true); |
|
$$1(_this.dom.panes).append(pane.dom.container); |
|
} |
|
if (!_this.s.dt.page.info().serverSide) { |
|
_this.s.dt.draw(); |
|
} |
|
if (_this.c.cascadePanes || _this.c.viewTotal) { |
|
_this.redrawPanes(_this.c.cascadePanes); |
|
} |
|
else { |
|
_this._updateSelection(); |
|
} |
|
_this._checkMessage(); |
|
_this.s.dt.one('draw', function () { |
|
_this.s.dt.page(page).draw(false); |
|
}); |
|
}); |
|
} |
|
}); |
|
// PreSelect any selections which have been defined using the preSelect option |
|
for (var _h = 0, _j = this.s.panes; _h < _j.length; _h++) { |
|
var pane = _j[_h]; |
|
if (pane !== undefined && |
|
pane.s.dtPane !== undefined && |
|
((pane.s.colOpts.preSelect !== undefined && pane.s.colOpts.preSelect.length > 0) || |
|
(pane.customPaneSettings !== null && |
|
pane.customPaneSettings.preSelect !== undefined && |
|
pane.customPaneSettings.preSelect.length > 0))) { |
|
var tableLength = pane.s.dtPane.rows().data().toArray().length; |
|
for (var i = 0; i < tableLength; i++) { |
|
if (pane.s.colOpts.preSelect.indexOf(pane.s.dtPane.cell(i, 0).data()) !== -1 || |
|
(pane.customPaneSettings !== null && |
|
pane.customPaneSettings.preSelect !== undefined && |
|
pane.customPaneSettings.preSelect.indexOf(pane.s.dtPane.cell(i, 0).data()) !== -1)) { |
|
pane.s.dtPane.row(i).select(); |
|
} |
|
} |
|
pane.updateTable(); |
|
} |
|
} |
|
if (this.s.selectionList !== undefined && this.s.selectionList.length > 0) { |
|
var last = this.s.selectionList[this.s.selectionList.length - 1].index; |
|
for (var _k = 0, _l = this.s.panes; _k < _l.length; _k++) { |
|
var pane = _l[_k]; |
|
pane.s.lastSelect = (pane.s.index === last); |
|
} |
|
} |
|
// If cascadePanes is active then make the previous selections in the order they were previously |
|
if (this.s.selectionList.length > 0 && this.c.cascadePanes) { |
|
this._cascadeRegen(this.s.selectionList); |
|
} |
|
// Update the title bar to show how many filters have been selected |
|
this._updateFilterCount(); |
|
// If the table is destroyed and restarted then clear the selections so that they do not persist. |
|
table.on('destroy.dtsps', function () { |
|
for (var _i = 0, _a = _this.s.panes; _i < _a.length; _i++) { |
|
var pane = _a[_i]; |
|
pane.destroy(); |
|
} |
|
table.off('.dtsps'); |
|
$$1(_this.dom.clearAll).off('.dtsps'); |
|
$$1(_this.dom.container).remove(); |
|
_this.clearSelections(); |
|
}); |
|
// When the clear All button has been pressed clear all of the selections in the panes |
|
if (this.c.clear) { |
|
$$1(this.dom.clearAll).on('click.dtsps', function () { |
|
_this.clearSelections(); |
|
}); |
|
} |
|
table.settings()[0]._searchPanes = this; |
|
}; |
|
SearchPanes.prototype._prepViewTotal = function () { |
|
var filterPane = this.s.filterPane; |
|
var filterActive = false; |
|
for (var _i = 0, _a = this.s.panes; _i < _a.length; _i++) { |
|
var pane = _a[_i]; |
|
if (pane.s.dtPane !== undefined) { |
|
var selectLength = pane.s.dtPane.rows({ selected: true }).data().toArray().length; |
|
// If filterPane === -1 then a pane with a selection has not been found yet, so set filterPane to that panes index |
|
if (selectLength > 0 && filterPane === -1) { |
|
filterPane = pane.s.index; |
|
filterActive = true; |
|
} |
|
// Then if another pane is found with a selection then set filterPane to null to |
|
// show that multiple panes have selections present |
|
else if (selectLength > 0) { |
|
filterPane = null; |
|
} |
|
} |
|
} |
|
// Update all of the panes to reflect the current state of the filters |
|
for (var _b = 0, _c = this.s.panes; _b < _c.length; _b++) { |
|
var pane = _c[_b]; |
|
if (pane.s.dtPane !== undefined) { |
|
pane.s.filteringActive = true; |
|
if ((filterPane !== -1 && filterPane !== null && filterPane === pane.s.index) || filterActive === false) { |
|
pane.s.filteringActive = false; |
|
} |
|
} |
|
} |
|
}; |
|
/** |
|
* Updates the number of filters that have been applied in the title |
|
*/ |
|
SearchPanes.prototype._updateFilterCount = function () { |
|
var filterCount = 0; |
|
// Add the number of all of the filters throughout the panes |
|
for (var _i = 0, _a = this.s.panes; _i < _a.length; _i++) { |
|
var pane = _a[_i]; |
|
if (pane.s.dtPane !== undefined) { |
|
filterCount += pane.getPaneCount(); |
|
} |
|
} |
|
// Run the message through the internationalisation method to improve readability |
|
var message = this.s.dt.i18n('searchPanes.title', 'Filters Active - %d', filterCount); |
|
$$1(this.dom.title).text(message); |
|
if (this.c.filterChanged !== undefined && typeof this.c.filterChanged === 'function') { |
|
this.c.filterChanged.call(this.s.dt, filterCount); |
|
} |
|
}; |
|
/** |
|
* Updates the selectionList when cascade is not in place |
|
*/ |
|
SearchPanes.prototype._updateSelection = function () { |
|
this.s.selectionList = []; |
|
for (var _i = 0, _a = this.s.panes; _i < _a.length; _i++) { |
|
var pane = _a[_i]; |
|
if (pane.s.dtPane !== undefined) { |
|
this.s.selectionList.push({ index: pane.s.index, rows: pane.s.dtPane.rows({ selected: true }).data().toArray(), protect: false }); |
|
} |
|
} |
|
this.s.dt.state.save(); |
|
}; |
|
SearchPanes.version = '1.2.1'; |
|
SearchPanes.classes = { |
|
clear: 'dtsp-clear', |
|
clearAll: 'dtsp-clearAll', |
|
container: 'dtsp-searchPanes', |
|
emptyMessage: 'dtsp-emptyMessage', |
|
hide: 'dtsp-hidden', |
|
panes: 'dtsp-panesContainer', |
|
search: 'dtsp-search', |
|
title: 'dtsp-title', |
|
titleRow: 'dtsp-titleRow' |
|
}; |
|
// Define SearchPanes default options |
|
SearchPanes.defaults = { |
|
cascadePanes: false, |
|
clear: true, |
|
container: function (dt) { |
|
return dt.table().container(); |
|
}, |
|
columns: [], |
|
filterChanged: undefined, |
|
layout: 'columns-3', |
|
order: [], |
|
panes: [], |
|
viewTotal: false |
|
}; |
|
return SearchPanes; |
|
}()); |
|
|
|
/*! SearchPanes 1.2.1 |
|
* 2019-2020 SpryMedia Ltd - datatables.net/license |
|
*/ |
|
// DataTables extensions common UMD. Note that this allows for AMD, CommonJS |
|
// (with window and jQuery being allowed as parameters to the returned |
|
// function) or just default browser loading. |
|
(function (factory) { |
|
if (typeof define === 'function' && define.amd) { |
|
// AMD |
|
define(['jquery', 'datatables.net'], function ($) { |
|
return factory($, window, document); |
|
}); |
|
} |
|
else if (typeof exports === 'object') { |
|
// CommonJS |
|
module.exports = function (root, $) { |
|
if (!root) { |
|
root = window; |
|
} |
|
if (!$ || !$.fn.dataTable) { |
|
$ = require('datatables.net')(root, $).$; |
|
} |
|
return factory($, root, root.document); |
|
}; |
|
} |
|
else { |
|
// Browser - assume jQuery has already been loaded |
|
factory(window.jQuery, window, document); |
|
} |
|
}(function ($, window, document) { |
|
setJQuery($); |
|
setJQuery$1($); |
|
var DataTable = $.fn.dataTable; |
|
$.fn.dataTable.SearchPanes = SearchPanes; |
|
$.fn.DataTable.SearchPanes = SearchPanes; |
|
$.fn.dataTable.SearchPane = SearchPane; |
|
$.fn.DataTable.SearchPane = SearchPane; |
|
var apiRegister = $.fn.dataTable.Api.register; |
|
apiRegister('searchPanes()', function () { |
|
return this; |
|
}); |
|
apiRegister('searchPanes.clearSelections()', function () { |
|
return this.iterator('table', function (ctx) { |
|
if (ctx._searchPanes) { |
|
ctx._searchPanes.clearSelections(); |
|
} |
|
}); |
|
}); |
|
apiRegister('searchPanes.rebuildPane()', function (targetIdx, maintainSelections) { |
|
return this.iterator('table', function (ctx) { |
|
if (ctx._searchPanes) { |
|
ctx._searchPanes.rebuild(targetIdx, maintainSelections); |
|
} |
|
}); |
|
}); |
|
apiRegister('searchPanes.container()', function () { |
|
var ctx = this.context[0]; |
|
return ctx._searchPanes |
|
? ctx._searchPanes.getNode() |
|
: null; |
|
}); |
|
$.fn.dataTable.ext.buttons.searchPanesClear = { |
|
text: 'Clear Panes', |
|
action: function (e, dt, node, config) { |
|
dt.searchPanes.clearSelections(); |
|
} |
|
}; |
|
$.fn.dataTable.ext.buttons.searchPanes = { |
|
action: function (e, dt, node, config) { |
|
e.stopPropagation(); |
|
this.popover(config._panes.getNode(), { |
|
align: 'dt-container' |
|
}); |
|
config._panes.rebuild(undefined, true); |
|
}, |
|
config: {}, |
|
init: function (dt, node, config) { |
|
var panes = new $.fn.dataTable.SearchPanes(dt, $.extend({ |
|
filterChanged: function (count) { |
|
dt.button(node).text(dt.i18n('searchPanes.collapse', { 0: 'SearchPanes', _: 'SearchPanes (%d)' }, count)); |
|
} |
|
}, config.config)); |
|
var message = dt.i18n('searchPanes.collapse', 'SearchPanes', 0); |
|
dt.button(node).text(message); |
|
config._panes = panes; |
|
}, |
|
text: 'Search Panes' |
|
}; |
|
function _init(settings, fromPre) { |
|
if (fromPre === void 0) { fromPre = false; } |
|
var api = new DataTable.Api(settings); |
|
var opts = api.init().searchPanes || DataTable.defaults.searchPanes; |
|
var searchPanes = new SearchPanes(api, opts, fromPre); |
|
var node = searchPanes.getNode(); |
|
return node; |
|
} |
|
// Attach a listener to the document which listens for DataTables initialisation |
|
// events so we can automatically initialise |
|
$(document).on('preInit.dt.dtsp', function (e, settings, json) { |
|
if (e.namespace !== 'dt') { |
|
return; |
|
} |
|
if (settings.oInit.searchPanes || |
|
DataTable.defaults.searchPanes) { |
|
if (!settings._searchPanes) { |
|
_init(settings, true); |
|
} |
|
} |
|
}); |
|
// DataTables `dom` feature option |
|
DataTable.ext.feature.push({ |
|
cFeature: 'P', |
|
fnInit: _init |
|
}); |
|
// DataTables 2 layout feature |
|
if (DataTable.ext.features) { |
|
DataTable.ext.features.register('searchPanes', _init); |
|
} |
|
})); |
|
|
|
}());
|
|
|