2016-05-14 12:04:00 +02:00
|
|
|
import {Feature} from '../../feature';
|
2016-05-15 04:56:12 +02:00
|
|
|
import {isArray, isFn, isUndef} from '../../types';
|
2016-05-25 09:31:53 +02:00
|
|
|
import {createElm, elm, getText, tag} from '../../dom';
|
2016-06-02 06:13:56 +02:00
|
|
|
import {addEvt} from '../../event';
|
2016-05-21 03:33:49 +02:00
|
|
|
import {formatDate} from '../../date';
|
2016-05-20 09:21:42 +02:00
|
|
|
import {removeNbFormat} from '../../helpers';
|
2016-05-08 03:48:51 +02:00
|
|
|
import {NONE, CELL_TAG, HEADER_TAG} from '../../const';
|
2015-03-01 11:44:39 +01:00
|
|
|
|
2016-05-14 12:04:00 +02:00
|
|
|
export default class AdapterSortableTable extends Feature {
|
2015-03-01 11:44:39 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* SortableTable Adapter module
|
|
|
|
* @param {Object} tf TableFilter instance
|
|
|
|
*/
|
2016-05-07 13:59:42 +02:00
|
|
|
constructor(tf, opts) {
|
2016-05-14 12:04:00 +02:00
|
|
|
super(tf, opts.name);
|
|
|
|
|
2015-06-07 12:30:32 +02:00
|
|
|
this.name = opts.name;
|
|
|
|
this.desc = opts.description || 'Sortable table';
|
|
|
|
|
2016-05-14 12:04:00 +02:00
|
|
|
//indicates if table previously sorted
|
2015-03-01 11:44:39 +01:00
|
|
|
this.sorted = false;
|
|
|
|
|
2016-05-15 04:56:12 +02:00
|
|
|
this.sortTypes = isArray(opts.types) ? opts.types : [];
|
|
|
|
this.sortColAtStart = isArray(opts.sort_col_at_start) ?
|
2015-06-07 12:30:32 +02:00
|
|
|
opts.sort_col_at_start : null;
|
|
|
|
this.asyncSort = Boolean(opts.async_sort);
|
2016-05-15 04:56:12 +02:00
|
|
|
this.triggerIds = isArray(opts.trigger_ids) ? opts.trigger_ids : [];
|
2015-06-07 12:30:32 +02:00
|
|
|
|
|
|
|
// edit .sort-arrow.descending / .sort-arrow.ascending in
|
|
|
|
// tablefilter.css to reflect any path change
|
|
|
|
this.imgPath = opts.images_path || tf.themesPath;
|
|
|
|
this.imgBlank = opts.image_blank || 'blank.png';
|
|
|
|
this.imgClassName = opts.image_class_name || 'sort-arrow';
|
|
|
|
this.imgAscClassName = opts.image_asc_class_name || 'ascending';
|
2016-05-07 13:59:42 +02:00
|
|
|
this.imgDescClassName = opts.image_desc_class_name || 'descending';
|
2015-03-01 11:44:39 +01:00
|
|
|
//cell attribute storing custom key
|
2015-06-12 09:42:28 +02:00
|
|
|
this.customKey = opts.custom_key || 'data-tf-sortKey';
|
2015-03-01 11:44:39 +01:00
|
|
|
|
|
|
|
// callback invoked after sort is loaded and instanciated
|
2016-05-15 04:56:12 +02:00
|
|
|
this.onSortLoaded = isFn(opts.on_sort_loaded) ?
|
2015-06-07 12:30:32 +02:00
|
|
|
opts.on_sort_loaded : null;
|
2015-03-01 11:44:39 +01:00
|
|
|
// callback invoked before table is sorted
|
2016-05-15 04:56:12 +02:00
|
|
|
this.onBeforeSort = isFn(opts.on_before_sort) ?
|
2015-06-07 12:30:32 +02:00
|
|
|
opts.on_before_sort : null;
|
2015-03-01 11:44:39 +01:00
|
|
|
// callback invoked after table is sorted
|
2016-05-15 04:56:12 +02:00
|
|
|
this.onAfterSort = isFn(opts.on_after_sort) ? opts.on_after_sort : null;
|
2015-03-01 11:44:39 +01:00
|
|
|
|
2016-05-14 12:04:00 +02:00
|
|
|
this.enable();
|
2015-03-01 11:44:39 +01:00
|
|
|
}
|
|
|
|
|
2016-05-07 13:59:42 +02:00
|
|
|
init() {
|
2016-05-14 12:04:00 +02:00
|
|
|
if (this.initialized) {
|
|
|
|
return;
|
|
|
|
}
|
2015-06-07 12:30:32 +02:00
|
|
|
let tf = this.tf;
|
|
|
|
let adpt = this;
|
2015-03-01 11:44:39 +01:00
|
|
|
|
|
|
|
// SortableTable class sanity check (sortabletable.js)
|
2016-05-15 04:56:12 +02:00
|
|
|
if (isUndef(SortableTable)) {
|
2015-03-01 11:44:39 +01:00
|
|
|
throw new Error('SortableTable class not found.');
|
|
|
|
}
|
|
|
|
|
2015-03-06 09:49:30 +01:00
|
|
|
this.overrideSortableTable();
|
|
|
|
this.setSortTypes();
|
2015-03-01 11:44:39 +01:00
|
|
|
|
|
|
|
//Column sort at start
|
2015-06-07 12:30:32 +02:00
|
|
|
let sortColAtStart = adpt.sortColAtStart;
|
2016-05-07 13:59:42 +02:00
|
|
|
if (sortColAtStart) {
|
2015-06-07 12:30:32 +02:00
|
|
|
this.stt.sort(sortColAtStart[0], sortColAtStart[1]);
|
2015-03-01 11:44:39 +01:00
|
|
|
}
|
|
|
|
|
2016-05-07 13:59:42 +02:00
|
|
|
if (this.onSortLoaded) {
|
2015-03-01 11:44:39 +01:00
|
|
|
this.onSortLoaded.call(null, tf, this);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*** SortableTable callbacks ***/
|
2016-05-07 13:59:42 +02:00
|
|
|
this.stt.onbeforesort = function () {
|
|
|
|
if (adpt.onBeforeSort) {
|
2015-10-31 12:26:48 +01:00
|
|
|
adpt.onBeforeSort.call(null, tf, adpt.stt.sortColumn);
|
2015-03-01 11:44:39 +01:00
|
|
|
}
|
2015-03-06 09:49:30 +01:00
|
|
|
|
2015-03-01 11:44:39 +01:00
|
|
|
/*** sort behaviour for paging ***/
|
2016-05-07 13:59:42 +02:00
|
|
|
if (tf.paging) {
|
2015-11-21 12:12:47 +01:00
|
|
|
tf.feature('paging').disable();
|
2015-03-01 11:44:39 +01:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2016-05-07 13:59:42 +02:00
|
|
|
this.stt.onsort = function () {
|
2015-04-04 10:10:09 +02:00
|
|
|
adpt.sorted = true;
|
2015-03-01 11:44:39 +01:00
|
|
|
|
|
|
|
//sort behaviour for paging
|
2016-05-07 13:59:42 +02:00
|
|
|
if (tf.paging) {
|
2015-06-08 12:21:50 +02:00
|
|
|
let paginator = tf.feature('paging');
|
2015-12-20 06:58:39 +01:00
|
|
|
// recalculate valid rows index as sorting may have change it
|
|
|
|
tf.getValidRows(true);
|
2015-11-21 12:12:47 +01:00
|
|
|
paginator.enable();
|
2015-06-13 11:03:33 +02:00
|
|
|
paginator.setPage(paginator.getPage());
|
2015-03-01 11:44:39 +01:00
|
|
|
}
|
|
|
|
|
2016-05-07 13:59:42 +02:00
|
|
|
if (adpt.onAfterSort) {
|
2016-04-12 18:39:20 +02:00
|
|
|
adpt.onAfterSort.call(null, tf, adpt.stt.sortColumn,
|
2016-05-07 13:59:42 +02:00
|
|
|
adpt.stt.descending);
|
2015-03-01 11:44:39 +01:00
|
|
|
}
|
2016-01-02 04:43:00 +01:00
|
|
|
|
2016-04-12 18:39:20 +02:00
|
|
|
adpt.emitter.emit('column-sorted', tf, adpt.stt.sortColumn,
|
|
|
|
adpt.stt.descending);
|
2015-03-01 11:44:39 +01:00
|
|
|
};
|
2015-06-07 12:30:32 +02:00
|
|
|
|
2016-04-13 18:28:12 +02:00
|
|
|
this.emitter.on(['sort'],
|
2016-05-07 13:59:42 +02:00
|
|
|
(tf, colIdx, desc) => this.sortByColumnIndex(colIdx, desc));
|
2016-04-13 18:28:12 +02:00
|
|
|
|
2015-06-07 12:30:32 +02:00
|
|
|
this.initialized = true;
|
2016-04-13 18:28:12 +02:00
|
|
|
this.emitter.emit('sort-initialized', tf, this);
|
2015-03-01 11:44:39 +01:00
|
|
|
}
|
|
|
|
|
2015-04-04 10:10:09 +02:00
|
|
|
/**
|
|
|
|
* Sort specified column
|
2015-10-31 12:26:48 +01:00
|
|
|
* @param {Number} colIdx Column index
|
|
|
|
* @param {Boolean} desc Optional: descending manner
|
2015-04-04 10:10:09 +02:00
|
|
|
*/
|
2016-05-07 13:59:42 +02:00
|
|
|
sortByColumnIndex(colIdx, desc) {
|
2015-10-31 12:26:48 +01:00
|
|
|
this.stt.sort(colIdx, desc);
|
2015-04-04 10:10:09 +02:00
|
|
|
}
|
|
|
|
|
2016-05-07 13:59:42 +02:00
|
|
|
overrideSortableTable() {
|
2015-06-07 12:30:32 +02:00
|
|
|
let adpt = this,
|
2015-03-01 11:44:39 +01:00
|
|
|
tf = this.tf;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Overrides headerOnclick method in order to handle th event
|
|
|
|
* @param {Object} e [description]
|
|
|
|
*/
|
2016-05-07 13:59:42 +02:00
|
|
|
SortableTable.prototype.headerOnclick = function (evt) {
|
|
|
|
if (!adpt.initialized) {
|
2015-03-01 11:44:39 +01:00
|
|
|
return;
|
|
|
|
}
|
2015-06-07 12:30:32 +02:00
|
|
|
|
2015-03-01 11:44:39 +01:00
|
|
|
// find Header element
|
2015-06-07 12:30:32 +02:00
|
|
|
let el = evt.target || evt.srcElement;
|
2015-03-01 11:44:39 +01:00
|
|
|
|
2016-05-08 03:48:51 +02:00
|
|
|
while (el.tagName !== CELL_TAG && el.tagName !== HEADER_TAG) {
|
2015-03-01 11:44:39 +01:00
|
|
|
el = el.parentNode;
|
|
|
|
}
|
|
|
|
|
|
|
|
this.sort(
|
|
|
|
SortableTable.msie ?
|
|
|
|
SortableTable.getCellIndex(el) : el.cellIndex
|
|
|
|
);
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Overrides getCellIndex IE returns wrong cellIndex when columns are
|
|
|
|
* hidden
|
|
|
|
* @param {Object} oTd TD element
|
|
|
|
* @return {Number} Cell index
|
|
|
|
*/
|
2016-05-07 13:59:42 +02:00
|
|
|
SortableTable.getCellIndex = function (oTd) {
|
2015-06-07 12:30:32 +02:00
|
|
|
let cells = oTd.parentNode.cells,
|
2015-03-01 11:44:39 +01:00
|
|
|
l = cells.length, i;
|
2016-05-15 05:33:16 +02:00
|
|
|
for (i = 0; cells[i] !== oTd && i < l; i++) { }
|
2015-03-01 11:44:39 +01:00
|
|
|
return i;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Overrides initHeader in order to handle filters row position
|
|
|
|
* @param {Array} oSortTypes
|
|
|
|
*/
|
2016-05-07 13:59:42 +02:00
|
|
|
SortableTable.prototype.initHeader = function (oSortTypes) {
|
2015-06-07 12:30:32 +02:00
|
|
|
let stt = this;
|
2016-05-07 13:59:42 +02:00
|
|
|
if (!stt.tHead) {
|
|
|
|
if (tf.gridLayout) {
|
2015-06-07 17:31:15 +02:00
|
|
|
stt.tHead = tf.feature('gridLayout').headTbl.tHead;
|
2015-06-07 12:30:32 +02:00
|
|
|
} else {
|
|
|
|
return;
|
|
|
|
}
|
2015-03-01 11:44:39 +01:00
|
|
|
}
|
2015-06-07 12:30:32 +02:00
|
|
|
|
2015-03-01 11:44:39 +01:00
|
|
|
stt.headersRow = tf.headersRow;
|
2015-06-07 12:30:32 +02:00
|
|
|
let cells = stt.tHead.rows[stt.headersRow].cells;
|
2015-03-01 11:44:39 +01:00
|
|
|
stt.sortTypes = oSortTypes || [];
|
2015-06-07 12:30:32 +02:00
|
|
|
let l = cells.length;
|
|
|
|
let img, c;
|
|
|
|
|
|
|
|
for (let i = 0; i < l; i++) {
|
2015-03-01 11:44:39 +01:00
|
|
|
c = cells[i];
|
2016-05-07 13:59:42 +02:00
|
|
|
if (stt.sortTypes[i] !== null && stt.sortTypes[i] !== 'None') {
|
2015-03-01 11:44:39 +01:00
|
|
|
c.style.cursor = 'pointer';
|
2016-05-24 10:42:11 +02:00
|
|
|
img = createElm('img',
|
2015-06-07 12:30:32 +02:00
|
|
|
['src', adpt.imgPath + adpt.imgBlank]);
|
2015-03-01 11:44:39 +01:00
|
|
|
c.appendChild(img);
|
2016-05-07 13:59:42 +02:00
|
|
|
if (stt.sortTypes[i] !== null) {
|
|
|
|
c.setAttribute('_sortType', stt.sortTypes[i]);
|
2015-03-01 11:44:39 +01:00
|
|
|
}
|
2016-06-02 06:13:56 +02:00
|
|
|
addEvt(c, 'click', stt._headerOnclick);
|
2015-03-01 11:44:39 +01:00
|
|
|
} else {
|
|
|
|
c.setAttribute('_sortType', oSortTypes[i]);
|
|
|
|
c._sortType = 'None';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
stt.updateHeaderArrows();
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Overrides updateHeaderArrows in order to handle arrows indicators
|
|
|
|
*/
|
2016-05-07 13:59:42 +02:00
|
|
|
SortableTable.prototype.updateHeaderArrows = function () {
|
2015-06-07 12:30:32 +02:00
|
|
|
let stt = this;
|
|
|
|
let cells, l, img;
|
|
|
|
|
2015-03-01 11:44:39 +01:00
|
|
|
// external headers
|
2016-05-07 13:59:42 +02:00
|
|
|
if (adpt.asyncSort && adpt.triggerIds.length > 0) {
|
2015-06-07 12:30:32 +02:00
|
|
|
let triggers = adpt.triggerIds;
|
2015-03-01 11:44:39 +01:00
|
|
|
cells = [];
|
|
|
|
l = triggers.length;
|
2016-05-07 13:59:42 +02:00
|
|
|
for (let j = 0; j < triggers.length; j++) {
|
2016-05-25 09:31:53 +02:00
|
|
|
cells.push(elm(triggers[j]));
|
2015-03-01 11:44:39 +01:00
|
|
|
}
|
|
|
|
} else {
|
2016-05-07 13:59:42 +02:00
|
|
|
if (!this.tHead) {
|
2015-03-01 11:44:39 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
cells = stt.tHead.rows[stt.headersRow].cells;
|
|
|
|
l = cells.length;
|
|
|
|
}
|
2016-05-07 13:59:42 +02:00
|
|
|
for (let i = 0; i < l; i++) {
|
2015-06-07 12:30:32 +02:00
|
|
|
let cellAttr = cells[i].getAttribute('_sortType');
|
2016-05-07 13:59:42 +02:00
|
|
|
if (cellAttr !== null && cellAttr !== 'None') {
|
2015-03-01 11:44:39 +01:00
|
|
|
img = cells[i].lastChild || cells[i];
|
2016-05-07 13:59:42 +02:00
|
|
|
if (img.nodeName.toLowerCase() !== 'img') {
|
2016-05-24 10:42:11 +02:00
|
|
|
img = createElm('img',
|
2015-06-07 12:30:32 +02:00
|
|
|
['src', adpt.imgPath + adpt.imgBlank]);
|
2015-03-01 11:44:39 +01:00
|
|
|
cells[i].appendChild(img);
|
|
|
|
}
|
2016-05-07 13:59:42 +02:00
|
|
|
if (i === stt.sortColumn) {
|
|
|
|
img.className = adpt.imgClassName + ' ' +
|
2015-03-06 09:49:30 +01:00
|
|
|
(this.descending ?
|
2015-06-07 12:30:32 +02:00
|
|
|
adpt.imgDescClassName :
|
|
|
|
adpt.imgAscClassName);
|
2016-05-07 13:59:42 +02:00
|
|
|
} else {
|
2015-06-07 12:30:32 +02:00
|
|
|
img.className = adpt.imgClassName;
|
2015-03-01 11:44:39 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Overrides getRowValue for custom key value feature
|
|
|
|
* @param {Object} oRow Row element
|
|
|
|
* @param {String} sType
|
|
|
|
* @param {Number} nColumn
|
|
|
|
* @return {String}
|
|
|
|
*/
|
2016-05-07 13:59:42 +02:00
|
|
|
SortableTable.prototype.getRowValue = function (oRow, sType, nColumn) {
|
2015-06-07 12:30:32 +02:00
|
|
|
let stt = this;
|
2015-03-01 11:44:39 +01:00
|
|
|
// if we have defined a custom getRowValue use that
|
2015-06-07 12:30:32 +02:00
|
|
|
let sortTypeInfo = stt._sortTypeInfo[sType];
|
2016-05-07 13:59:42 +02:00
|
|
|
if (sortTypeInfo && sortTypeInfo.getRowValue) {
|
2015-03-01 11:44:39 +01:00
|
|
|
return sortTypeInfo.getRowValue(oRow, nColumn);
|
|
|
|
}
|
2015-06-07 12:30:32 +02:00
|
|
|
let c = oRow.cells[nColumn];
|
|
|
|
let s = SortableTable.getInnerText(c);
|
2015-03-01 11:44:39 +01:00
|
|
|
return stt.getValueFromString(s, sType);
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Overrides getInnerText in order to avoid Firefox unexpected sorting
|
|
|
|
* behaviour with untrimmed text elements
|
|
|
|
* @param {Object} oNode DOM element
|
|
|
|
* @return {String} DOM element inner text
|
|
|
|
*/
|
2016-05-07 13:59:42 +02:00
|
|
|
SortableTable.getInnerText = function (oNode) {
|
|
|
|
if (!oNode) {
|
2015-04-11 11:05:59 +02:00
|
|
|
return;
|
|
|
|
}
|
2016-05-07 13:59:42 +02:00
|
|
|
if (oNode.getAttribute(adpt.customKey)) {
|
2015-06-07 12:30:32 +02:00
|
|
|
return oNode.getAttribute(adpt.customKey);
|
2015-03-01 11:44:39 +01:00
|
|
|
} else {
|
2016-05-24 10:42:11 +02:00
|
|
|
return getText(oNode);
|
2015-03-01 11:44:39 +01:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2016-05-07 13:59:42 +02:00
|
|
|
addSortType() {
|
2015-06-08 12:21:50 +02:00
|
|
|
var args = arguments;
|
|
|
|
SortableTable.prototype.addSortType(args[0], args[1], args[2], args[3]);
|
2015-04-04 10:10:09 +02:00
|
|
|
}
|
|
|
|
|
2016-05-07 13:59:42 +02:00
|
|
|
setSortTypes() {
|
2015-06-07 12:30:32 +02:00
|
|
|
let tf = this.tf,
|
|
|
|
sortTypes = this.sortTypes,
|
|
|
|
_sortTypes = [];
|
2015-03-01 11:44:39 +01:00
|
|
|
|
2016-05-07 13:59:42 +02:00
|
|
|
for (let i = 0; i < tf.nbCells; i++) {
|
2015-06-07 12:30:32 +02:00
|
|
|
let colType;
|
2015-03-01 11:44:39 +01:00
|
|
|
|
2016-05-07 13:59:42 +02:00
|
|
|
if (sortTypes[i]) {
|
2015-06-07 12:30:32 +02:00
|
|
|
colType = sortTypes[i].toLowerCase();
|
2016-05-07 13:59:42 +02:00
|
|
|
if (colType === NONE) {
|
2015-03-01 11:44:39 +01:00
|
|
|
colType = 'None';
|
|
|
|
}
|
|
|
|
} else { // resolve column types
|
2016-05-07 13:59:42 +02:00
|
|
|
if (tf.hasColNbFormat && tf.colNbFormat[i] !== null) {
|
2015-03-01 11:44:39 +01:00
|
|
|
colType = tf.colNbFormat[i].toLowerCase();
|
2016-05-07 13:59:42 +02:00
|
|
|
} else if (tf.hasColDateType && tf.colDateType[i] !== null) {
|
|
|
|
colType = tf.colDateType[i].toLowerCase() + 'date';
|
2015-03-01 11:44:39 +01:00
|
|
|
} else {
|
|
|
|
colType = 'String';
|
|
|
|
}
|
|
|
|
}
|
2015-06-07 12:30:32 +02:00
|
|
|
_sortTypes.push(colType);
|
2015-03-01 11:44:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
//Public TF method to add sort type
|
|
|
|
|
|
|
|
//Custom sort types
|
|
|
|
this.addSortType('number', Number);
|
|
|
|
this.addSortType('caseinsensitivestring', SortableTable.toUpperCase);
|
|
|
|
this.addSortType('date', SortableTable.toDate);
|
|
|
|
this.addSortType('string');
|
2015-04-04 10:10:09 +02:00
|
|
|
this.addSortType('us', usNumberConverter);
|
|
|
|
this.addSortType('eu', euNumberConverter);
|
2016-05-07 13:59:42 +02:00
|
|
|
this.addSortType('dmydate', dmyDateConverter);
|
2015-04-04 10:10:09 +02:00
|
|
|
this.addSortType('ymddate', ymdDateConverter);
|
|
|
|
this.addSortType('mdydate', mdyDateConverter);
|
|
|
|
this.addSortType('ddmmmyyyydate', ddmmmyyyyDateConverter);
|
|
|
|
this.addSortType('ipaddress', ipAddress, sortIP);
|
2015-03-01 11:44:39 +01:00
|
|
|
|
2015-06-07 12:30:32 +02:00
|
|
|
this.stt = new SortableTable(tf.tbl, _sortTypes);
|
2015-03-01 11:44:39 +01:00
|
|
|
|
|
|
|
/*** external table headers adapter ***/
|
2016-05-07 13:59:42 +02:00
|
|
|
if (this.asyncSort && this.triggerIds.length > 0) {
|
2015-06-07 12:30:32 +02:00
|
|
|
let triggers = this.triggerIds;
|
2016-05-07 13:59:42 +02:00
|
|
|
for (let j = 0; j < triggers.length; j++) {
|
|
|
|
if (triggers[j] === null) {
|
2015-03-01 11:44:39 +01:00
|
|
|
continue;
|
|
|
|
}
|
2016-05-25 09:31:53 +02:00
|
|
|
let trigger = elm(triggers[j]);
|
2016-05-07 13:59:42 +02:00
|
|
|
if (trigger) {
|
2015-03-01 11:44:39 +01:00
|
|
|
trigger.style.cursor = 'pointer';
|
2015-04-11 11:05:59 +02:00
|
|
|
|
2016-06-02 06:13:56 +02:00
|
|
|
addEvt(trigger, 'click', (evt) => {
|
2015-06-07 12:30:32 +02:00
|
|
|
let elm = evt.target;
|
2016-05-07 13:59:42 +02:00
|
|
|
if (!this.tf.sort) {
|
2015-03-01 11:44:39 +01:00
|
|
|
return;
|
|
|
|
}
|
2015-10-18 12:55:40 +02:00
|
|
|
this.stt.asyncSort(triggers.indexOf(elm.id));
|
2015-03-01 11:44:39 +01:00
|
|
|
});
|
2015-06-07 12:30:32 +02:00
|
|
|
trigger.setAttribute('_sortType', _sortTypes[j]);
|
2015-03-01 11:44:39 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-04 10:10:09 +02:00
|
|
|
/**
|
|
|
|
* Destroy sort
|
|
|
|
*/
|
2016-05-07 13:59:42 +02:00
|
|
|
destroy() {
|
2016-05-14 12:04:00 +02:00
|
|
|
if (!this.initialized) {
|
|
|
|
return;
|
|
|
|
}
|
2015-06-07 12:30:32 +02:00
|
|
|
let tf = this.tf;
|
2016-04-13 18:28:12 +02:00
|
|
|
this.emitter.off(['sort'],
|
2016-05-07 13:59:42 +02:00
|
|
|
(tf, colIdx, desc) => this.sortByColumnIndex(colIdx, desc));
|
2015-04-04 10:10:09 +02:00
|
|
|
this.sorted = false;
|
2015-06-07 12:30:32 +02:00
|
|
|
this.initialized = false;
|
2015-04-04 10:10:09 +02:00
|
|
|
this.stt.destroy();
|
|
|
|
|
2015-06-07 12:30:32 +02:00
|
|
|
let ids = tf.getFiltersId();
|
2016-05-07 13:59:42 +02:00
|
|
|
for (let idx = 0; idx < ids.length; idx++) {
|
2015-06-07 12:30:32 +02:00
|
|
|
let header = tf.getHeaderElement(idx);
|
2016-05-24 10:42:11 +02:00
|
|
|
let img = tag(header, 'img');
|
2015-04-04 10:10:09 +02:00
|
|
|
|
2016-05-07 13:59:42 +02:00
|
|
|
if (img.length === 1) {
|
2015-04-04 10:10:09 +02:00
|
|
|
header.removeChild(img[0]);
|
2015-03-01 11:44:39 +01:00
|
|
|
}
|
|
|
|
}
|
2016-05-14 12:04:00 +02:00
|
|
|
this.initialized = false;
|
2015-03-01 11:44:39 +01:00
|
|
|
}
|
|
|
|
|
2015-04-04 10:10:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
//Converters
|
2016-05-07 13:59:42 +02:00
|
|
|
function usNumberConverter(s) {
|
2016-05-20 09:21:42 +02:00
|
|
|
return removeNbFormat(s, 'us');
|
2015-04-04 10:10:09 +02:00
|
|
|
}
|
2016-05-07 13:59:42 +02:00
|
|
|
function euNumberConverter(s) {
|
2016-05-20 09:21:42 +02:00
|
|
|
return removeNbFormat(s, 'eu');
|
2015-04-04 10:10:09 +02:00
|
|
|
}
|
2016-05-07 13:59:42 +02:00
|
|
|
function dateConverter(s, format) {
|
2016-05-21 03:33:49 +02:00
|
|
|
return formatDate(s, format);
|
2015-04-04 10:10:09 +02:00
|
|
|
}
|
2016-05-07 13:59:42 +02:00
|
|
|
function dmyDateConverter(s) {
|
2015-04-04 10:10:09 +02:00
|
|
|
return dateConverter(s, 'DMY');
|
|
|
|
}
|
2016-05-07 13:59:42 +02:00
|
|
|
function mdyDateConverter(s) {
|
2015-04-04 10:10:09 +02:00
|
|
|
return dateConverter(s, 'MDY');
|
|
|
|
}
|
2016-05-07 13:59:42 +02:00
|
|
|
function ymdDateConverter(s) {
|
2015-04-04 10:10:09 +02:00
|
|
|
return dateConverter(s, 'YMD');
|
|
|
|
}
|
2016-05-07 13:59:42 +02:00
|
|
|
function ddmmmyyyyDateConverter(s) {
|
2015-04-04 10:10:09 +02:00
|
|
|
return dateConverter(s, 'DDMMMYYYY');
|
|
|
|
}
|
|
|
|
|
2016-05-07 13:59:42 +02:00
|
|
|
function ipAddress(value) {
|
2015-06-07 12:30:32 +02:00
|
|
|
let vals = value.split('.');
|
|
|
|
for (let x in vals) {
|
|
|
|
let val = vals[x];
|
2016-05-07 13:59:42 +02:00
|
|
|
while (3 > val.length) {
|
|
|
|
val = '0' + val;
|
2015-03-01 11:44:39 +01:00
|
|
|
}
|
2015-04-04 10:10:09 +02:00
|
|
|
vals[x] = val;
|
2015-03-01 11:44:39 +01:00
|
|
|
}
|
2015-04-04 10:10:09 +02:00
|
|
|
return vals.join('.');
|
|
|
|
}
|
|
|
|
|
2016-05-07 13:59:42 +02:00
|
|
|
function sortIP(a, b) {
|
2015-06-07 12:30:32 +02:00
|
|
|
let aa = ipAddress(a.value.toLowerCase());
|
|
|
|
let bb = ipAddress(b.value.toLowerCase());
|
2016-05-15 05:33:16 +02:00
|
|
|
if (aa === bb) {
|
2015-04-04 10:10:09 +02:00
|
|
|
return 0;
|
2016-05-07 13:59:42 +02:00
|
|
|
} else if (aa < bb) {
|
2015-04-04 10:10:09 +02:00
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|