| /*␊ |
| * 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