/*
* jQuery Dynatable plugin 0.3.1
*
* Copyright (c) 2014 Steve Schwartz (JangoSteve)
*
* Dual licensed under the AGPL and Proprietary licenses:
* http://www.dynatable.com/license/
*
* Date: Tue Jan 02 2014
*/
//
(function($) {
var defaults,
mergeSettings,
dt,
Model,
modelPrototypes = {
dom: Dom,
domColumns: DomColumns,
records: Records,
recordsCount: RecordsCount,
processingIndicator: ProcessingIndicator,
state: State,
sorts: Sorts,
sortsHeaders: SortsHeaders,
queries: Queries,
inputsSearch: InputsSearch,
paginationPage: PaginationPage,
paginationPerPage: PaginationPerPage,
paginationLinks: PaginationLinks
},
utility,
build,
processAll,
initModel,
defaultRowWriter,
defaultCellWriter,
defaultAttributeWriter,
defaultAttributeReader;
//-----------------------------------------------------------------
// Cached plugin global defaults
//-----------------------------------------------------------------
defaults = {
features: {
paginate: true,
sort: true,
pushState: true,
search: true,
recordCount: true,
perPageSelect: true
},
table: {
defaultColumnIdStyle: 'camelCase',
columns: null,
headRowSelector: 'thead tr', // or e.g. tr:first-child
bodyRowSelector: 'tbody tr',
headRowClass: null
},
inputs: {
queries: null,
sorts: null,
multisort: ['ctrlKey', 'shiftKey', 'metaKey'],
page: null,
queryEvent: 'blur change',
recordCountTarget: null,
recordCountPlacement: 'after',
paginationLinkTarget: null,
paginationLinkPlacement: 'after',
paginationClass: 'dynatable-pagination-links',
paginationLinkClass: 'dynatable-page-link',
paginationPrevClass: 'dynatable-page-prev',
paginationNextClass: 'dynatable-page-next',
paginationActiveClass: 'dynatable-active-page',
paginationDisabledClass: 'dynatable-disabled-page',
paginationPrev: 'Previous',
paginationNext: 'Next',
paginationGap: [1,2,2,1],
searchTarget: null,
searchPlacement: 'before',
perPageTarget: null,
perPagePlacement: 'before',
perPageText: 'Show: ',
recordCountText: 'Showing ',
processingText: 'Processing...'
},
dataset: {
ajax: false,
ajaxUrl: null,
ajaxCache: null,
ajaxOnLoad: false,
ajaxMethod: 'GET',
ajaxDataType: 'json',
totalRecordCount: null,
queries: {},
queryRecordCount: null,
page: null,
perPageDefault: 10,
perPageOptions: [10,20,50,100],
sorts: {},
sortsKeys: null,
sortTypes: {},
records: null
},
writers: {
_rowWriter: defaultRowWriter,
_cellWriter: defaultCellWriter,
_attributeWriter: defaultAttributeWriter
},
readers: {
_rowReader: null,
_attributeReader: defaultAttributeReader
},
params: {
dynatable: 'dynatable',
queries: 'queries',
sorts: 'sorts',
page: 'page',
perPage: 'perPage',
offset: 'offset',
records: 'records',
record: null,
queryRecordCount: 'queryRecordCount',
totalRecordCount: 'totalRecordCount'
}
};
//-----------------------------------------------------------------
// Each dynatable instance inherits from this,
// set properties specific to instance
//-----------------------------------------------------------------
dt = {
init: function(element, options) {
this.settings = mergeSettings(options);
this.element = element;
this.$element = $(element);
// All the setup that doesn't require element or options
build.call(this);
return this;
},
process: function(skipPushState) {
processAll.call(this, skipPushState);
}
};
//-----------------------------------------------------------------
// Cached plugin global functions
//-----------------------------------------------------------------
mergeSettings = function(options) {
var newOptions = $.extend(true, {}, defaults, options);
// TODO: figure out a better way to do this.
// Doing `extend(true)` causes any elements that are arrays
// to merge the default and options arrays instead of overriding the defaults.
if (options) {
if (options.inputs) {
if (options.inputs.multisort) {
newOptions.inputs.multisort = options.inputs.multisort;
}
if (options.inputs.paginationGap) {
newOptions.inputs.paginationGap = options.inputs.paginationGap;
}
}
if (options.dataset && options.dataset.perPageOptions) {
newOptions.dataset.perPageOptions = options.dataset.perPageOptions;
}
}
return newOptions;
};
build = function() {
this.$element.trigger('dynatable:preinit', this);
for (model in modelPrototypes) {
if (modelPrototypes.hasOwnProperty(model)) {
var modelInstance = this[model] = new modelPrototypes[model](this, this.settings);
if (modelInstance.initOnLoad()) {
modelInstance.init();
}
}
}
this.$element.trigger('dynatable:init', this);
if (!this.settings.dataset.ajax || (this.settings.dataset.ajax && this.settings.dataset.ajaxOnLoad) || this.settings.features.paginate) {
this.process();
}
};
processAll = function(skipPushState) {
var data = {};
this.$element.trigger('dynatable:beforeProcess', data);
if (!$.isEmptyObject(this.settings.dataset.queries)) { data[this.settings.params.queries] = this.settings.dataset.queries; }
// TODO: Wrap this in a try/rescue block to hide the processing indicator and indicate something went wrong if error
this.processingIndicator.show();
if (this.settings.features.sort && !$.isEmptyObject(this.settings.dataset.sorts)) { data[this.settings.params.sorts] = this.settings.dataset.sorts; }
if (this.settings.features.paginate && this.settings.dataset.page) {
var page = this.settings.dataset.page,
perPage = this.settings.dataset.perPage;
data[this.settings.params.page] = page;
data[this.settings.params.perPage] = perPage;
data[this.settings.params.offset] = (page - 1) * perPage;
}
if (this.settings.dataset.ajaxData) { $.extend(data, this.settings.dataset.ajaxData); }
// If ajax, sends query to ajaxUrl with queries and sorts serialized and appended in ajax data
// otherwise, executes queries and sorts on in-page data
if (this.settings.dataset.ajax) {
var _this = this;
var options = {
type: _this.settings.dataset.ajaxMethod,
dataType: _this.settings.dataset.ajaxDataType,
data: data,
error: function(xhr, error) {
},
success: function(response) {
_this.$element.trigger('dynatable:ajax:success', response);
// Merge ajax results and meta-data into dynatables cached data
_this.records.updateFromJson(response);
// update table with new records
_this.dom.update();
if (!skipPushState && _this.state.initOnLoad()) {
_this.state.push(data);
}
},
complete: function() {
_this.processingIndicator.hide();
}
};
// Do not pass url to `ajax` options if blank
if (this.settings.dataset.ajaxUrl) {
options.url = this.settings.dataset.ajaxUrl;
// If ajaxUrl is blank, then we're using the current page URL,
// we need to strip out any query, sort, or page data controlled by dynatable
// that may have been in URL when page loaded, so that it doesn't conflict with
// what's passed in with the data ajax parameter
} else {
options.url = utility.refreshQueryString(window.location.href, {}, this.settings);
}
if (this.settings.dataset.ajaxCache !== null) { options.cache = this.settings.dataset.ajaxCache; }
$.ajax(options);
} else {
this.records.resetOriginal();
this.queries.run();
if (this.settings.features.sort) {
this.records.sort();
}
if (this.settings.features.paginate) {
this.records.paginate();
}
this.dom.update();
this.processingIndicator.hide();
if (!skipPushState && this.state.initOnLoad()) {
this.state.push(data);
}
}
this.$element.trigger('dynatable:afterProcess', data);
};
function defaultRowWriter(rowIndex, record, columns, cellWriter) {
var tr = '';
// grab the record's attribute for each column
for (var i = 0, len = columns.length; i < len; i++) {
tr += cellWriter(columns[i], record);
}
return '<tr class="' + record.originalTR[0].className + '">' + tr + '</tr>';
};
function defaultCellWriter(column, record) {
var html = column.attributeWriter(record),
td = '<td';
if (column.hidden || column.textAlign) {
td += ' style="';
// keep cells for hidden column headers hidden
if (column.hidden) {
td += 'display: none;';
}
// keep cells aligned as their column headers are aligned
if (column.textAlign) {
td += 'text-align: ' + column.textAlign + ';';
}
td += '"';
}
return td + '>' + html + '</td>';
};
function defaultAttributeWriter(record) {
// `this` is the column object in settings.columns
// TODO: automatically convert common types, such as arrays and objects, to string
return record[this.id];
};
function defaultAttributeReader(cell, record) {
return $(cell).html();
};
//-----------------------------------------------------------------
// Dynatable object model prototype
// (all object models get these default functions)
//-----------------------------------------------------------------
Model = {
initOnLoad: function() {
return true;
},
init: function() {}
};
for (model in modelPrototypes) {
if (modelPrototypes.hasOwnProperty(model)) {
var modelPrototype = modelPrototypes[model];
modelPrototype.prototype = Model;
}
}
//-----------------------------------------------------------------
// Dynatable object models
//-----------------------------------------------------------------
function Dom(obj, settings) {
var _this = this;
// update table contents with new records array
// from query (whether ajax or not)
this.update = function() {
var rows = '',
columns = settings.table.columns,
rowWriter = settings.writers._rowWriter,
cellWriter = settings.writers._cellWriter;
obj.$element.trigger('dynatable:beforeUpdate', rows);
// loop through records
for (var i = 0, len = settings.dataset.records.length; i < len; i++) {
var record = settings.dataset.records[i],
tr = rowWriter(i, record, columns, cellWriter);
rows += tr;
}
// Appended dynatable interactive elements
if (settings.features.recordCount) {
$('#dynatable-record-count-' + obj.element.id).replaceWith(obj.recordsCount.create());
}
if (settings.features.paginate) {
$('#dynatable-pagination-links-' + obj.element.id).replaceWith(obj.paginationLinks.create());
if (settings.features.perPageSelect) {
$('#dynatable-per-page-' + obj.element.id).val(parseInt(settings.dataset.perPage));
}
}
// Sort headers functionality
if (settings.features.sort && columns) {
obj.sortsHeaders.removeAllArrows();
for (var i = 0, len = columns.length; i < len; i++) {
var column = columns[i],
sortedByColumn = utility.allMatch(settings.dataset.sorts, column.sorts, function(sorts, sort) { return sort in sorts; }),
value = settings.dataset.sorts[column.sorts[0]];
if (sortedByColumn) {
obj.$element.find('[data-dynatable-column="' + column.id + '"]').find('.dynatable-sort-header').each(function(){
if (value == 1) {
obj.sortsHeaders.appendArrowUp($(this));
} else {
obj.sortsHeaders.appendArrowDown($(this));
}
});
}
}
}
// Query search functionality
if (settings.inputs.queries || settings.features.search) {
var allQueries = settings.inputs.queries || $();
if (settings.features.search) {
allQueries = allQueries.add('#dynatable-query-search-' + obj.element.id);
}
allQueries.each(function() {
var $this = $(this),
q = settings.dataset.queries[$this.data('dynatable-query')];
$this.val(q || '');
});
}
obj.$element.find(settings.table.bodyRowSelector).remove();
obj.$element.append(rows);
obj.$element.trigger('dynatable:afterUpdate', rows);
};
};
function DomColumns(obj, settings) {
var _this = this;
this.initOnLoad = function() {
return obj.$element.is('table');
};
this.init = function() {
settings.table.columns = [];
this.getFromTable();
};
// initialize table[columns] array
this.getFromTable = function() {
var $columns = obj.$element.find(settings.table.headRowSelector).children('th,td');
if ($columns.length) {
$columns.each(function(index){
_this.add($(this), index, true);
});
} else {
return $.error("Couldn't find any columns headers in '" + settings.table.headRowSelector + " th,td'. If your header row is different, specify the selector in the table: headRowSelector option.");
}
};
this.add = function($column, position, skipAppend, skipUpdate) {
var columns = settings.table.columns,
label = $column.text(),
id = $column.data('dynatable-column') || utility.normalizeText(label, settings.table.defaultColumnIdStyle),
dataSorts = $column.data('dynatable-sorts'),
sorts = dataSorts ? $.map(dataSorts.split(','), function(text) { return $.trim(text); }) : [id];
// If the column id is blank, generate an id for it
if ( !id ) {
this.generate($column);
id = $column.data('dynatable-column');
}
// Add column data to plugin instance
columns.splice(position, 0, {
index: position,
label: label,
id: id,
attributeWriter: settings.writers[id] || settings.writers._attributeWriter,
attributeReader: settings.readers[id] || settings.readers._attributeReader,
sorts: sorts,
hidden: $column.css('display') === 'none',
textAlign: $column.css('text-align')
});
// Modify header cell
$column
.attr('data-dynatable-column', id)
.addClass('dynatable-head');
if (settings.table.headRowClass) { $column.addClass(settings.table.headRowClass); }
// Append column header to table
if (!skipAppend) {
var domPosition = position + 1,
$sibling = obj.$element.find(settings.table.headRowSelector)
.children('th:nth-child(' + domPosition + '),td:nth-child(' + domPosition + ')').first(),
columnsAfter = columns.slice(position + 1, columns.length);
if ($sibling.length) {
$sibling.before($column);
// sibling column doesn't yet exist (maybe this is the last column in the header row)
} else {
obj.$element.find(settings.table.headRowSelector).append($column);
}
obj.sortsHeaders.attachOne($column.get());
// increment the index of all columns after this one that was just inserted
if (columnsAfter.length) {
for (var i = 0, len = columnsAfter.length; i < len; i++) {
columnsAfter[i].index += 1;
}
}
if (!skipUpdate) {
obj.dom.update();
}
}
return dt;
};
this.remove = function(columnIndexOrId) {
var columns = settings.table.columns,
length = columns.length;
if (typeof(columnIndexOrId) === "number") {
var column = columns[columnIndexOrId];
this.removeFromTable(column.id);
this.removeFromArray(columnIndexOrId);
} else {
// Traverse columns array in reverse order so that subsequent indices
// don't get messed up when we delete an item from the array in an iteration
for (var i = columns.length - 1; i >= 0; i--) {
var column = columns[i];
if (column.id === columnIndexOrId) {
this.removeFromTable(columnIndexOrId);
this.removeFromArray(i);
}
}
}
obj.dom.update();
};
this.removeFromTable = function(columnId) {
obj.$element.find(settings.table.headRowSelector).children('[data-dynatable-column="' + columnId + '"]').first()
.remove();
};
this.removeFromArray = function(index) {
var columns = settings.table.columns,
adjustColumns;
columns.splice(index, 1);
adjustColumns = columns.slice(index, columns.length);
for (var i = 0, len = adjustColumns.length; i < len; i++) {
adjustColumns[i].index -= 1;
}
};
this.generate = function($cell) {
var cell = $cell === undefined ? $('<th></th>') : $cell;
return this.attachGeneratedAttributes(cell);
};
this.attachGeneratedAttributes = function($cell) {
// Use increment to create unique column name that is the same each time the page is reloaded,
// in order to avoid errors with mismatched attribute names when loading cached `dataset.records` array
var increment = obj.$element.find(settings.table.headRowSelector).children('th[data-dynatable-generated]').length;
return $cell
.attr('data-dynatable-column', 'dynatable-generated-' + increment) //+ utility.randomHash(),
.attr('data-dynatable-no-sort', 'true')
.attr('data-dynatable-generated', increment);
};
};
function Records(obj, settings) {
var _this = this;
this.initOnLoad = function() {
return !settings.dataset.ajax;
};
this.init = function() {
if (settings.dataset.records === null) {
settings.dataset.records = this.getFromTable();
if (!settings.dataset.queryRecordCount) {
settings.dataset.queryRecordCount = this.count();
}
if (!settings.dataset.totalRecordCount){
settings.dataset.totalRecordCount = settings.dataset.queryRecordCount;
}
}
// Create cache of original full recordset (unpaginated and unqueried)
settings.dataset.originalRecords = $.extend(true, [], settings.dataset.records);
};
// merge ajax response json with cached data including
// meta-data and records
this.updateFromJson = function(data) {
var records;
if (settings.params.records === "_root") {
records = data;
} else if (settings.params.records in data) {
records = data[settings.params.records];
}
if (settings.params.record) {
var len = records.length - 1;
for (var i = 0; i < len; i++) {
records[i] = records[i][settings.params.record];
}
}
if (settings.params.queryRecordCount in data) {
settings.dataset.queryRecordCount = data[settings.params.queryRecordCount];
}
if (settings.params.totalRecordCount in data) {
settings.dataset.totalRecordCount = data[settings.params.totalRecordCount];
}
settings.dataset.records = records;
};
// For really advanced sorting,
// see http://james.padolsey.com/javascript/sorting-elements-with-jquery/
this.sort = function() {
var sort = [].sort,
sorts = settings.dataset.sorts,
sortsKeys = settings.dataset.sortsKeys,
sortTypes = settings.dataset.sortTypes;
var sortFunction = function(a, b) {
var comparison;
if ($.isEmptyObject(sorts)) {
comparison = obj.sorts.functions['originalPlacement'](a, b);
} else {
for (var i = 0, len = sortsKeys.length; i < len; i++) {
var attr = sortsKeys[i],
direction = sorts[attr],
sortType = sortTypes[attr] || obj.sorts.guessType(a, b, attr);
comparison = obj.sorts.functions[sortType](a, b, attr, direction);
// Don't need to sort any further unless this sort is a tie between a and b,
// so break the for loop unless tied
if (comparison !== 0) { break; }
}
}
return comparison;
}
return sort.call(settings.dataset.records, sortFunction);
};
this.paginate = function() {
var bounds = this.pageBounds(),
first = bounds[0], last = bounds[1];
settings.dataset.records = settings.dataset.records.slice(first, last);
};
this.resetOriginal = function() {
settings.dataset.records = settings.dataset.originalRecords || [];
};
this.pageBounds = function() {
var page = settings.dataset.page || 1,
first = (page - 1) * settings.dataset.perPage,
last = Math.min(first + settings.dataset.perPage, settings.dataset.queryRecordCount);
return [first,last];
};
// get initial recordset to populate table
// if ajax, call ajaxUrl
// otherwise, initialize from in-table records
this.getFromTable = function() {
var records = [],
columns = settings.table.columns,
tableRecords = obj.$element.find(settings.table.bodyRowSelector);
tableRecords.each(function(index){
var record = {};
record['dynatable-original-index'] = index;
record["originalTR"] = $(this);
$(this).find('th,td').each(function(index) {
if (columns[index] === undefined) {
// Header cell didn't exist for this column, so let's generate and append
// a new header cell with a randomly generated name (so we can store and
// retrieve the contents of this column for each record)
obj.domColumns.add(obj.domColumns.generate(), columns.length, false, true); // don't skipAppend, do skipUpdate
}
var value = columns[index].attributeReader(this, record),
attr = columns[index].id;
// If value from table is HTML, let's get and cache the text equivalent for
// the default string sorting, since it rarely makes sense for sort headers
// to sort based on HTML tags.
if (typeof(value) === "string" && value.match(/\s*\<.+\>/)) {
if (! record['dynatable-sortable-text']) {
record['dynatable-sortable-text'] = {};
}
record['dynatable-sortable-text'][attr] = $.trim($('<div></div>').html(value).text());
}
record[attr] = value;
});
// Allow configuration function which alters record based on attributes of
// table row (e.g. from html5 data- attributes)
if (typeof(settings.readers._rowReader) === "function") {
settings.readers._rowReader(index, this, record);
}
records.push(record);
});
return records; // 1st row is header
};
// count records from table
this.count = function() {
return settings.dataset.records.length;
};
};
function RecordsCount(obj, settings) {
this.initOnLoad = function() {
return settings.features.recordCount;
};
this.init = function() {
this.attach();
};
this.create = function() {
var recordsShown = obj.records.count(),
recordsQueryCount = settings.dataset.queryRecordCount,
recordsTotal = settings.dataset.totalRecordCount,
text = settings.inputs.recordCountText,
collection_name = settings.params.records;
if (recordsShown < recordsQueryCount && settings.features.paginate) {
var bounds = obj.records.pageBounds();
text += "<span class='dynatable-record-bounds'>" + (bounds[0] + 1) + " to " + bounds[1] + "</span> of ";
} else if (recordsShown === recordsQueryCount && settings.features.paginate) {
text += recordsShown + " of ";
}
text += recordsQueryCount + " " + collection_name;
if (recordsQueryCount < recordsTotal) {
text += " (filtered from " + recordsTotal + " total records)";
}
return $('<span></span>', {
id: 'dynatable-record-count-' + obj.element.id,
'class': 'dynatable-record-count',
html: text
});
};
this.attach = function() {
var $target = settings.inputs.recordCountTarget ? $(settings.inputs.recordCountTarget) : obj.$element;
$target[settings.inputs.recordCountPlacement](this.create());
};
};
function ProcessingIndicator(obj, settings) {
this.init = function() {
this.attach();
};
this.create = function() {
var $processing = $('<div></div>', {
html: '<span>' + settings.inputs.processingText + '</span>',
id: 'dynatable-processing-' + obj.element.id,
'class': 'dynatable-processing',
style: 'position: absolute; display: none;'
});
return $processing;
};
this.position = function() {
var $processing = $('#dynatable-processing-' + obj.element.id),
$span = $processing.children('span'),
spanHeight = $span.outerHeight(),
spanWidth = $span.outerWidth(),
$covered = obj.$element,
offset = $covered.offset(),
height = $covered.outerHeight(), width = $covered.outerWidth();
$processing
.offset({left: offset.left, top: offset.top})
.width(width)
.height(height)
$span
.offset({left: offset.left + ( (width - spanWidth) / 2 ), top: offset.top + ( (height - spanHeight) / 2 )});
return $processing;
};
this.attach = function() {
obj.$element.before(this.create());
};
this.show = function() {
$('#dynatable-processing-' + obj.element.id).show();
this.position();
};
this.hide = function() {
$('#dynatable-processing-' + obj.element.id).hide();
};
};
function State(obj, settings) {
this.initOnLoad = function() {
// Check if pushState option is true, and if browser supports it
return settings.features.pushState && history.pushState;
};
this.init = function() {
window.onpopstate = function(event) {
if (event.state && event.state.dynatable) {
obj.state.pop(event);
}
}
};
this.push = function(data) {
var urlString = window.location.search,
urlOptions,
path,
params,
hash,
newParams,
cacheStr,
cache,
// replaceState on initial load, then pushState after that
firstPush = !(window.history.state && window.history.state.dynatable),
pushFunction = firstPush ? 'replaceState' : 'pushState';
if (urlString && /^\?/.test(urlString)) { urlString = urlString.substring(1); }
$.extend(urlOptions, data);
params = utility.refreshQueryString(urlString, data, settings);
if (params) { params = '?' + params; }
hash = window.location.hash;
path = window.location.pathname;
obj.$element.trigger('dynatable:push', data);
cache = { dynatable: { dataset: settings.dataset } };
if (!firstPush) { cache.dynatable.scrollTop = $(window).scrollTop(); }
cacheStr = JSON.stringify(cache);
// Mozilla has a 640k char limit on what can be stored in pushState.
// See "limit" in https://developer.mozilla.org/en/DOM/Manipulating_the_browser_history#The_pushState().C2.A0method
// and "dataStr.length" in http://wine.git.sourceforge.net/git/gitweb.cgi?p=wine/wine-gecko;a=patch;h=43a11bdddc5fc1ff102278a120be66a7b90afe28
//
// Likewise, other browsers may have varying (undocumented) limits.
// Also, Firefox's limit can be changed in about:config as browser.history.maxStateObjectSize
// Since we don't know what the actual limit will be in any given situation, we'll just try caching and rescue
// any exceptions by retrying pushState without caching the records.
//
// I have absolutely no idea why perPageOptions suddenly becomes an array-like object instead of an array,
// but just recently, this started throwing an error if I don't convert it:
// 'Uncaught Error: DATA_CLONE_ERR: DOM Exception 25'
cache.dynatable.dataset.perPageOptions = $.makeArray(cache.dynatable.dataset.perPageOptions);
try {
window.history[pushFunction](cache, "Dynatable state", path + params + hash);
} catch(error) {
// Make cached records = null, so that `pop` will rerun process to retrieve records
cache.dynatable.dataset.records = null;
window.history[pushFunction](cache, "Dynatable state", path + params + hash);
}
};
this.pop = function(event) {
var data = event.state.dynatable;
settings.dataset = data.dataset;
if (data.scrollTop) { $(window).scrollTop(data.scrollTop); }
// If dataset.records is cached from pushState
if ( data.dataset.records ) {
obj.dom.update();
} else {
obj.process(true);
}
};
};
function Sorts(obj, settings) {
this.initOnLoad = function() {
return settings.features.sort;
};
this.init = function() {
var sortsUrl = window.location.search.match(new RegExp(settings.params.sorts + '[^&=]*=[^&]*', 'g'));
settings.dataset.sorts = sortsUrl ? utility.deserialize(sortsUrl)[settings.params.sorts] : {};
settings.dataset.sortsKeys = sortsUrl ? utility.keysFromObject(settings.dataset.sorts) : [];
};
this.add = function(attr, direction) {
var sortsKeys = settings.dataset.sortsKeys,
index = $.inArray(attr, sortsKeys);
settings.dataset.sorts[attr] = direction;
if (index === -1) { sortsKeys.push(attr); }
return dt;
};
this.remove = function(attr) {
var sortsKeys = settings.dataset.sortsKeys,
index = $.inArray(attr, sortsKeys);
delete settings.dataset.sorts[attr];
if (index !== -1) { sortsKeys.splice(index, 1); }
return dt;
};
this.clear = function() {
settings.dataset.sorts = {};
settings.dataset.sortsKeys.length = 0;
};
// Try to intelligently guess which sort function to use
// based on the type of attribute values.
// Consider using something more robust than `typeof` (http://javascriptweblog.wordpress.com/2011/08/08/fixing-the-javascript-typeof-operator/)
this.guessType = function(a, b, attr) {
var types = {
string: 'string',
number: 'number',
'boolean': 'number',
object: 'number' // dates and null values are also objects, this works...
},
attrType = a[attr] ? typeof(a[attr]) : typeof(b[attr]),
type = types[attrType] || 'number';
return type;
};
// Built-in sort functions
// (the most common use-cases I could think of)
this.functions = {
number: function(a, b, attr, direction) {
return a[attr] === b[attr] ? 0 : (direction > 0 ? a[attr] - b[attr] : b[attr] - a[attr]);
},
string: function(a, b, attr, direction) {
var aAttr = (a['dynatable-sortable-text'] && a['dynatable-sortable-text'][attr]) ? a['dynatable-sortable-text'][attr] : a[attr],
bAttr = (b['dynatable-sortable-text'] && b['dynatable-sortable-text'][attr]) ? b['dynatable-sortable-text'][attr] : b[attr],
comparison;
aAttr = aAttr.toLowerCase();
bAttr = bAttr.toLowerCase();
comparison = aAttr === bAttr ? 0 : (direction > 0 ? aAttr > bAttr : bAttr > aAttr);
// force false boolean value to -1, true to 1, and tie to 0
return comparison === false ? -1 : (comparison - 0);
},
originalPlacement: function(a, b) {
return a['dynatable-original-index'] - b['dynatable-original-index'];
}
};
};
// turn table headers into links which add sort to sorts array
function SortsHeaders(obj, settings) {
var _this = this;
this.initOnLoad = function() {
return settings.features.sort;
};
this.init = function() {
this.attach();
};
this.create = function(cell) {
var $cell = $(cell),
$link = $('<a></a>', {
'class': 'dynatable-sort-header',
href: '#',
html: $cell.html()
}),
id = $cell.data('dynatable-column'),
column = utility.findObjectInArray(settings.table.columns, {id: id});
$link.bind('click', function(e) {
_this.toggleSort(e, $link, column);
obj.process();
e.preventDefault();
});
if (this.sortedByColumn($link, column)) {
if (this.sortedByColumnValue(column) == 1) {
this.appendArrowUp($link);
} else {
this.appendArrowDown($link);
}
}
return $link;
};
this.removeAll = function() {
obj.$element.find(settings.table.headRowSelector).children('th,td').each(function(){
_this.removeAllArrows();
_this.removeOne(this);
});
};
this.removeOne = function(cell) {
var $cell = $(cell),
$link = $cell.find('.dynatable-sort-header');
if ($link.length) {
var html = $link.html();
$link.remove();
$cell.html($cell.html() + html);
}
};
this.attach = function() {
obj.$element.find(settings.table.headRowSelector).children('th,td').each(function(){
_this.attachOne(this);
});
};
this.attachOne = function(cell) {
var $cell = $(cell);
if (!$cell.data('dynatable-no-sort')) {
$cell.html(this.create(cell));
}
};
this.appendArrowUp = function($link) {
this.removeArrow($link);
$link.append("<span class='dynatable-arrow'> ▲</span>");
};
this.appendArrowDown = function($link) {
this.removeArrow($link);
$link.append("<span class='dynatable-arrow'> ▼</span>");
};
this.removeArrow = function($link) {
// Not sure why `parent()` is needed, the arrow should be inside the link from `append()` above
$link.find('.dynatable-arrow').remove();
};
this.removeAllArrows = function() {
obj.$element.find('.dynatable-arrow').remove();
};
this.toggleSort = function(e, $link, column) {
var sortedByColumn = this.sortedByColumn($link, column),
value = this.sortedByColumnValue(column);
// Clear existing sorts unless this is a multisort event
if (!settings.inputs.multisort || !utility.anyMatch(e, settings.inputs.multisort, function(evt, key) { return e[key]; })) {
this.removeAllArrows();
obj.sorts.clear();
}
// If sorts for this column are already set
if (sortedByColumn) {
// If ascending, then make descending
if (value == 1) {
for (var i = 0, len = column.sorts.length; i < len; i++) {
obj.sorts.add(column.sorts[i], -1);
}
this.appendArrowDown($link);
// If descending, remove sort
} else {
for (var i = 0, len = column.sorts.length; i < len; i++) {
obj.sorts.remove(column.sorts[i]);
}
this.removeArrow($link);
}
// Otherwise, if not already set, set to ascending
} else {
for (var i = 0, len = column.sorts.length; i < len; i++) {
obj.sorts.add(column.sorts[i], 1);
}
this.appendArrowUp($link);
}
};
this.sortedByColumn = function($link, column) {
return utility.allMatch(settings.dataset.sorts, column.sorts, function(sorts, sort) { return sort in sorts; });
};
this.sortedByColumnValue = function(column) {
return settings.dataset.sorts[column.sorts[0]];
};
};
function Queries(obj, settings) {
var _this = this;
this.initOnLoad = function() {
return settings.inputs.queries || settings.features.search;
};
this.init = function() {
var queriesUrl = window.location.search.match(new RegExp(settings.params.queries + '[^&=]*=[^&]*', 'g'));
settings.dataset.queries = queriesUrl ? utility.deserialize(queriesUrl)[settings.params.queries] : {};
if (settings.dataset.queries === "") { settings.dataset.queries = {}; }
if (settings.inputs.queries) {
this.setupInputs();
}
};
this.add = function(name, value) {
// reset to first page since query will change records
if (settings.features.paginate) {
settings.dataset.page = 1;
}
settings.dataset.queries[name] = value;
return dt;
};
this.remove = function(name) {
delete settings.dataset.queries[name];
return dt;
};
this.run = function() {
for (query in settings.dataset.queries) {
if (settings.dataset.queries.hasOwnProperty(query)) {
var value = settings.dataset.queries[query];
if (_this.functions[query] === undefined) {
// Try to lazily evaluate query from column names if not explicitly defined
var queryColumn = utility.findObjectInArray(settings.table.columns, {id: query});
if (queryColumn) {
_this.functions[query] = function(record, queryValue) {
return record[query] == queryValue;
};
} else {
$.error("Query named '" + query + "' called, but not defined in queries.functions");
continue; // to skip to next query
}
}
// collect all records that return true for query
settings.dataset.records = $.map(settings.dataset.records, function(record) {
return _this.functions[query](record, value) ? record : null;
});
}
}
settings.dataset.queryRecordCount = obj.records.count();
};
// Shortcut for performing simple query from built-in search
this.runSearch = function(q) {
var origQueries = $.extend({}, settings.dataset.queries);
if (q) {
this.add('search', q);
} else {
this.remove('search');
}
if (!utility.objectsEqual(settings.dataset.queries, origQueries)) {
obj.process();
}
};
this.setupInputs = function() {
settings.inputs.queries.each(function() {
var $this = $(this),
event = $this.data('dynatable-query-event') || settings.inputs.queryEvent,
query = $this.data('dynatable-query') || $this.attr('name') || this.id,
queryFunction = function(e) {
var q = $(this).val();
if (q === "") { q = undefined; }
if (q === settings.dataset.queries[query]) { return false; }
if (q) {
_this.add(query, q);
} else {
_this.remove(query);
}
obj.process();
e.preventDefault();
};
$this
.attr('data-dynatable-query', query)
.bind(event, queryFunction)
.bind('keypress', function(e) {
if (e.which == 13) {
queryFunction.call(this, e);
}
});
if (settings.dataset.queries[query]) { $this.val(decodeURIComponent(settings.dataset.queries[query])); }
});
};
// Query functions for in-page querying
// each function should take a record and a value as input
// and output true of false as to whether the record is a match or not
this.functions = {
search: function(record, queryValue) {
var contains = false;
// Loop through each attribute of record
for (attr in record) {
if (record.hasOwnProperty(attr)) {
var attrValue = record[attr];
if (typeof(attrValue) === "string" && attrValue.toLowerCase().indexOf(queryValue.toLowerCase()) !== -1) {
contains = true;
// Don't need to keep searching attributes once found
break;
} else {
continue;
}
}
}
return contains;
}
};
};
function InputsSearch(obj, settings) {
var _this = this;
this.initOnLoad = function() {
return settings.features.search;
};
this.init = function() {
this.attach();
};
this.create = function() {
var $search = $('<input />', {
type: 'search',
id: 'dynatable-query-search-' + obj.element.id,
'data-dynatable-query': 'search',
value: settings.dataset.queries.search
}),
$searchSpan = $('<span></span>', {
id: 'dynatable-search-' + obj.element.id,
'class': 'dynatable-search',
text: 'Search: '
}).append($search);
$search
.bind(settings.inputs.queryEvent, function() {
obj.queries.runSearch($(this).val());
})
.bind('keypress', function(e) {
if (e.which == 13) {
obj.queries.runSearch($(this).val());
e.preventDefault();
}
});
return $searchSpan;
};
this.attach = function() {
var $target = settings.inputs.searchTarget ? $(settings.inputs.searchTarget) : obj.$element;
$target[settings.inputs.searchPlacement](this.create());
};
};
// provide a public function for selecting page
function PaginationPage(obj, settings) {
this.initOnLoad = function() {
return settings.features.paginate;
};
this.init = function() {
var pageUrl = window.location.search.match(new RegExp(settings.params.page + '=([^&]*)'));
// If page is present in URL parameters and pushState is enabled
// (meaning that it'd be possible for dynatable to have put the
// page parameter in the URL)
if (pageUrl && settings.features.pushState) {
this.set(pageUrl[1]);
} else {
this.set(1);
}
};
this.set = function(page) {
settings.dataset.page = parseInt(page, 10);
}
};
function PaginationPerPage(obj, settings) {
var _this = this;
this.initOnLoad = function() {
return settings.features.paginate;
};
this.init = function() {
var perPageUrl = window.location.search.match(new RegExp(settings.params.perPage + '=([^&]*)'));
// If perPage is present in URL parameters and pushState is enabled
// (meaning that it'd be possible for dynatable to have put the
// perPage parameter in the URL)
if (perPageUrl && settings.features.pushState) {
// Don't reset page to 1 on init, since it might override page
// set on init from URL
this.set(perPageUrl[1], true);
} else {
this.set(settings.dataset.perPageDefault, true);
}
if (settings.features.perPageSelect) {
this.attach();
}
};
this.create = function() {
var $select = $('<select>', {
id: 'dynatable-per-page-' + obj.element.id,
'class': 'dynatable-per-page-select'
});
for (var i = 0, len = settings.dataset.perPageOptions.length; i < len; i++) {
var number = settings.dataset.perPageOptions[i],
selected = settings.dataset.perPage == number ? 'selected="selected"' : '';
$select.append('<option value="' + number + '" ' + selected + '>' + number + '</option>');
}
$select.bind('change', function(e) {
_this.set($(this).val());
obj.process();
});
return $('<span />', {
'class': 'dynatable-per-page'
}).append("<span class='dynatable-per-page-label'>" + settings.inputs.perPageText + "</span>").append($select);
};
this.attach = function() {
var $target = settings.inputs.perPageTarget ? $(settings.inputs.perPageTarget) : obj.$element;
$target[settings.inputs.perPagePlacement](this.create());
};
this.set = function(number, skipResetPage) {
if (!skipResetPage) { obj.paginationPage.set(1); }
settings.dataset.perPage = parseInt(number);
};
};
// pagination links which update dataset.page attribute
function PaginationLinks(obj, settings) {
var _this = this;
this.initOnLoad = function() {
return settings.features.paginate;
};
this.init = function() {
this.attach();
};
this.create = function() {
var pageLinks = '<ul id="' + 'dynatable-pagination-links-' + obj.element.id + '" class="' + settings.inputs.paginationClass + '">',
pageLinkClass = settings.inputs.paginationLinkClass,
activePageClass = settings.inputs.paginationActiveClass,
disabledPageClass = settings.inputs.paginationDisabledClass,
pages = Math.ceil(settings.dataset.queryRecordCount / settings.dataset.perPage),
page = settings.dataset.page,
breaks = [
settings.inputs.paginationGap[0],
settings.dataset.page - settings.inputs.paginationGap[1],
settings.dataset.page + settings.inputs.paginationGap[2],
(pages + 1) - settings.inputs.paginationGap[3]
];
pageLinks += '<li><span>Pages: </span></li>';
for (var i = 1; i <= pages; i++) {
if ( (i > breaks[0] && i < breaks[1]) || (i > breaks[2] && i < breaks[3])) {
// skip to next iteration in loop
continue;
} else {
var li = obj.paginationLinks.buildLink(i, i, pageLinkClass, page == i, activePageClass),
breakIndex,
nextBreak;
// If i is not between one of the following
// (1 + (settings.paginationGap[0]))
// (page - settings.paginationGap[1])
// (page + settings.paginationGap[2])
// (pages - settings.paginationGap[3])
breakIndex = $.inArray(i, breaks);
nextBreak = breaks[breakIndex + 1];
if (breakIndex > 0 && i !== 1 && nextBreak && nextBreak > (i + 1)) {
var ellip = '<li><span class="dynatable-page-break">…</span></li>';
li = breakIndex < 2 ? ellip + li : li + ellip;
}
if (settings.inputs.paginationPrev && i === 1) {
var prevLi = obj.paginationLinks.buildLink(page - 1, settings.inputs.paginationPrev, pageLinkClass + ' ' + settings.inputs.paginationPrevClass, page === 1, disabledPageClass);
li = prevLi + li;
}
if (settings.inputs.paginationNext && i === pages) {
var nextLi = obj.paginationLinks.buildLink(page + 1, settings.inputs.paginationNext, pageLinkClass + ' ' + settings.inputs.paginationNextClass, page === pages, disabledPageClass);
li += nextLi;
}
pageLinks += li;
}
}
pageLinks += '</ul>';
// only bind page handler to non-active and non-disabled page links
var selector = '#dynatable-pagination-links-' + obj.element.id + ' a.' + pageLinkClass + ':not(.' + activePageClass + ',.' + disabledPageClass + ')';
// kill any existing delegated-bindings so they don't stack up
$(document).undelegate(selector, 'click.dynatable');
$(document).delegate(selector, 'click.dynatable', function(e) {
$this = $(this);
$this.closest(settings.inputs.paginationClass).find('.' + activePageClass).removeClass(activePageClass);
$this.addClass(activePageClass);
obj.paginationPage.set($this.data('dynatable-page'));
obj.process();
e.preventDefault();
});
return pageLinks;
};
this.buildLink = function(page, label, linkClass, conditional, conditionalClass) {
var link = '<a data-dynatable-page=' + page + ' class="' + linkClass,
li = '<li';
if (conditional) {
link += ' ' + conditionalClass;
li += ' class="' + conditionalClass + '"';
}
link += '">' + label + '</a>';
li += '>' + link + '</li>';
return li;
};
this.attach = function() {
// append page links *after* delegate-event-binding so it doesn't need to
// find and select all page links to bind event
var $target = settings.inputs.paginationLinkTarget ? $(settings.inputs.paginationLinkTarget) : obj.$element;
$target[settings.inputs.paginationLinkPlacement](obj.paginationLinks.create());
};
};
utility = dt.utility = {
normalizeText: function(text, style) {
text = this.textTransform[style](text);
return text;
},
textTransform: {
trimDash: function(text) {
return text.replace(/^\s+|\s+$/g, "").replace(/\s+/g, "-");
},
camelCase: function(text) {
text = this.trimDash(text);
return text
.replace(/(\-[a-zA-Z])/g, function($1){return $1.toUpperCase().replace('-','');})
.replace(/([A-Z])([A-Z]+)/g, function($1,$2,$3){return $2 + $3.toLowerCase();})
.replace(/^[A-Z]/, function($1){return $1.toLowerCase();});
},
dashed: function(text) {
text = this.trimDash(text);
return this.lowercase(text);
},
underscore: function(text) {
text = this.trimDash(text);
return this.lowercase(text.replace(/(-)/g, '_'));
},
lowercase: function(text) {
return text.replace(/([A-Z])/g, function($1){return $1.toLowerCase();});
}
},
// Deserialize params in URL to object
// see http://stackoverflow.com/questions/1131630/javascript-jquery-param-inverse-function/3401265#3401265
deserialize: function(query) {
if (!query) return {};
// modified to accept an array of partial URL strings
if (typeof(query) === "object") { query = query.join('&'); }
var hash = {},
vars = query.split("&");
for (var i = 0; i < vars.length; i++) {
var pair = vars[i].split("="),
k = decodeURIComponent(pair[0]),
v, m;
if (!pair[1]) { continue };
v = decodeURIComponent(pair[1].replace(/\+/g, ' '));
// modified to parse multi-level parameters (e.g. "hi[there][dude]=whatsup" => hi: {there: {dude: "whatsup"}})
while (m = k.match(/([^&=]+)\[([^&=]+)\]$/)) {
var origV = v;
k = m[1];
v = {};
// If nested param ends in '][', then the regex above erroneously included half of a trailing '[]',
// which indicates the end-value is part of an array
if (m[2].substr(m[2].length-2) == '][') { // must use substr for IE to understand it
v[m[2].substr(0,m[2].length-2)] = [origV];
} else {
v[m[2]] = origV;
}
}
// If it is the first entry with this name
if (typeof hash[k] === "undefined") {
if (k.substr(k.length-2) != '[]') { // not end with []. cannot use negative index as IE doesn't understand it
hash[k] = v;
} else {
hash[k] = [v];
}
// If subsequent entry with this name and not array
} else if (typeof hash[k] === "string") {
hash[k] = v; // replace it
// modified to add support for objects
} else if (typeof hash[k] === "object") {
hash[k] = $.extend({}, hash[k], v);
// If subsequent entry with this name and is array
} else {
hash[k].push(v);
}
}
return hash;
},
refreshQueryString: function(urlString, data, settings) {
var _this = this,
queryString = urlString.split('?'),
path = queryString.shift(),
urlOptions;
urlOptions = this.deserialize(urlString);
// Loop through each dynatable param and update the URL with it
for (attr in settings.params) {
if (settings.params.hasOwnProperty(attr)) {
var label = settings.params[attr];
// Skip over parameters matching attributes for disabled features (i.e. leave them untouched),
// because if the feature is turned off, then parameter name is a coincidence and it's unrelated to dynatable.
if (
(!settings.features.sort && attr == "sorts") ||
(!settings.features.paginate && _this.anyMatch(attr, ["page", "perPage", "offset"], function(attr, param) { return attr == param; }))
) {
continue;
}
// Delete page and offset from url params if on page 1 (default)
if ((attr === "page" || attr === "offset") && data["page"] === 1) {
if (urlOptions[label]) {
delete urlOptions[label];
}
continue;
}
// Delete perPage from url params if default perPage value
if (attr === "perPage" && data[label] == settings.dataset.perPageDefault) {
if (urlOptions[label]) {
delete urlOptions[label];
}
continue;
}
// For queries, we're going to handle each possible query parameter individually here instead of
// handling the entire queries object below, since we need to make sure that this is a query controlled by dynatable.
if (attr == "queries" && data[label]) {
var queries = settings.inputs.queries || [],
inputQueries = $.makeArray(queries.map(function() { return $(this).attr('name') }));
if (settings.features.search) { inputQueries.push('search'); }
for (var i = 0, len = inputQueries.length; i < len; i++) {
var attr = inputQueries[i];
if (data[label][attr]) {
if (typeof urlOptions[label] === 'undefined') { urlOptions[label] = {}; }
urlOptions[label][attr] = data[label][attr];
} else {
delete urlOptions[label][attr];
}
}
continue;
}
// If we haven't returned true by now, then we actually want to update the parameter in the URL
if (data[label]) {
urlOptions[label] = data[label];
} else {
delete urlOptions[label];
}
}
}
return decodeURI($.param(urlOptions));
},
// Get array of keys from object
// see http://stackoverflow.com/questions/208016/how-to-list-the-properties-of-a-javascript-object/208020#208020
keysFromObject: function(obj){
var keys = [];
for (var key in obj){
keys.push(key);
}
return keys;
},
// Find an object in an array of objects by attributes.
// E.g. find object with {id: 'hi', name: 'there'} in an array of objects
findObjectInArray: function(array, objectAttr) {
var _this = this,
foundObject;
for (var i = 0, len = array.length; i < len; i++) {
var item = array[i];
// For each object in array, test to make sure all attributes in objectAttr match
if (_this.allMatch(item, objectAttr, function(item, key, value) { return item[key] == value; })) {
foundObject = item;
break;
}
}
return foundObject;
},
// Return true if supplied test function passes for ALL items in an array
allMatch: function(item, arrayOrObject, test) {
// start off with true result by default
var match = true,
isArray = $.isArray(arrayOrObject);
// Loop through all items in array
$.each(arrayOrObject, function(key, value) {
var result = isArray ? test(item, value) : test(item, key, value);
// If a single item tests false, go ahead and break the array by returning false
// and return false as result,
// otherwise, continue with next iteration in loop
// (if we make it through all iterations without overriding match with false,
// then we can return the true result we started with by default)
if (!result) { return match = false; }
});
return match;
},
// Return true if supplied test function passes for ANY items in an array
anyMatch: function(item, arrayOrObject, test) {
var match = false,
isArray = $.isArray(arrayOrObject);
$.each(arrayOrObject, function(key, value) {
var result = isArray ? test(item, value) : test(item, key, value);
if (result) {
// As soon as a match is found, set match to true, and return false to stop the `$.each` loop
match = true;
return false;
}
});
return match;
},
// Return true if two objects are equal
// (i.e. have the same attributes and attribute values)
objectsEqual: function(a, b) {
for (attr in a) {
if (a.hasOwnProperty(attr)) {
if (!b.hasOwnProperty(attr) || a[attr] !== b[attr]) {
return false;
}
}
}
for (attr in b) {
if (b.hasOwnProperty(attr) && !a.hasOwnProperty(attr)) {
return false;
}
}
return true;
},
// Taken from http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/105074#105074
randomHash: function() {
return (((1+Math.random())*0x10000)|0).toString(16).substring(1);
}
};
//-----------------------------------------------------------------
// Build the dynatable plugin
//-----------------------------------------------------------------
// Object.create support test, and fallback for browsers without it
if ( typeof Object.create !== "function" ) {
Object.create = function (o) {
function F() {}
F.prototype = o;
return new F();
};
}
//-----------------------------------------------------------------
// Global dynatable plugin setting defaults
//-----------------------------------------------------------------
$.dynatableSetup = function(options) {
defaults = mergeSettings(options);
};
// Create dynatable plugin based on a defined object
$.dynatable = function( object ) {
$.fn['dynatable'] = function( options ) {
return this.each(function() {
if ( ! $.data( this, 'dynatable' ) ) {
$.data( this, 'dynatable', Object.create(object).init(this, options) );
}
});
};
};
$.dynatable(dt);
})(jQuery);
accountmanagementengine