diff --git a/helpdesk/query.py b/helpdesk/query.py index 0ee6373c..869e800a 100644 --- a/helpdesk/query.py +++ b/helpdesk/query.py @@ -77,13 +77,16 @@ def get_search_filter_args(search): DATATABLES_ORDER_COLUMN_CHOICES = Choices( ('0', 'id'), + ('1', 'title'), ('2', 'priority'), - ('3', 'title'), - ('4', 'queue'), - ('5', 'status'), - ('6', 'created'), - ('7', 'due_date'), - ('8', 'assigned_to') + ('3', 'queue'), + ('4', 'status'), + ('5', 'created'), + ('6', 'due_date'), + ('7', 'assigned_to'), + ('8', 'submitter_email'), + #('9', 'time_spent'), + ('10', 'kbitem'), ) @@ -123,10 +126,9 @@ class __Query__: sorting: The name of the column to sort by """ - for key in self.params.get('filtering', {}).keys(): - filter = {key: self.params['filtering'][key]} - queryset = queryset.filter(**filter) - queryset = queryset.filter(self.get_search_filter_args()) + filter = self.params.get('filtering', {}) + filter_or = self.params.get('filtering_or', {}) + queryset = queryset.filter((Q(**filter) | Q(**filter_or)) & self.get_search_filter_args()) sorting = self.params.get('sorting', None) if sorting: sortreverse = self.params.get('sortreverse', None) @@ -177,7 +179,7 @@ class __Query__: queryset = objects.all().order_by(order_by) total = queryset.count() - if search_value: + if search_value: # Dead code currently queryset = queryset.filter(get_search_filter_args(search_value)) count = queryset.count() diff --git a/helpdesk/serializers.py b/helpdesk/serializers.py index 469fc92e..7dd51346 100644 --- a/helpdesk/serializers.py +++ b/helpdesk/serializers.py @@ -22,13 +22,14 @@ class DatatablesTicketSerializer(serializers.ModelSerializer): row_class = serializers.SerializerMethodField() time_spent = serializers.SerializerMethodField() queue = serializers.SerializerMethodField() + kbitem = serializers.SerializerMethodField() class Meta: model = Ticket # fields = '__all__' fields = ('ticket', 'id', 'priority', 'title', 'queue', 'status', 'created', 'due_date', 'assigned_to', 'submitter', 'row_class', - 'time_spent') + 'time_spent', 'kbitem') def get_queue(self, obj): return ({"title": obj.queue.title, "id": obj.queue.id}) @@ -62,3 +63,7 @@ class DatatablesTicketSerializer(serializers.ModelSerializer): def get_row_class(self, obj): return (obj.get_priority_css_class) + + def get_kbitem(self, obj): + return obj.kbitem.title if obj.kbitem else "" + diff --git a/helpdesk/static/helpdesk/vendor/datatables/css/buttons.dataTables.css b/helpdesk/static/helpdesk/vendor/datatables/css/buttons.dataTables.css new file mode 100644 index 00000000..d8e63ed7 --- /dev/null +++ b/helpdesk/static/helpdesk/vendor/datatables/css/buttons.dataTables.css @@ -0,0 +1,380 @@ +@keyframes dtb-spinner { + 100% { + transform: rotate(360deg); + } +} +@-o-keyframes dtb-spinner { + 100% { + -o-transform: rotate(360deg); + transform: rotate(360deg); + } +} +@-ms-keyframes dtb-spinner { + 100% { + -ms-transform: rotate(360deg); + transform: rotate(360deg); + } +} +@-webkit-keyframes dtb-spinner { + 100% { + -webkit-transform: rotate(360deg); + transform: rotate(360deg); + } +} +@-moz-keyframes dtb-spinner { + 100% { + -moz-transform: rotate(360deg); + transform: rotate(360deg); + } +} +div.dt-button-info { + position: fixed; + top: 50%; + left: 50%; + width: 400px; + margin-top: -100px; + margin-left: -200px; + background-color: white; + border: 2px solid #111; + box-shadow: 3px 3px 8px rgba(0, 0, 0, 0.3); + border-radius: 3px; + text-align: center; + z-index: 21; +} +div.dt-button-info h2 { + padding: 0.5em; + margin: 0; + font-weight: normal; + border-bottom: 1px solid #ddd; + background-color: #f3f3f3; +} +div.dt-button-info > div { + padding: 1em; +} + +div.dt-button-collection-title { + text-align: center; + padding: 0.3em 0 0.5em; + font-size: 0.9em; +} + +div.dt-button-collection-title:empty { + display: none; +} + +button.dt-button, +div.dt-button, +a.dt-button { + position: relative; + display: inline-block; + box-sizing: border-box; + margin-right: 0.333em; + margin-bottom: 0.333em; + padding: 0.5em 1em; + border: 1px solid #999; + border-radius: 2px; + cursor: pointer; + font-size: 0.88em; + line-height: 1.6em; + color: black; + white-space: nowrap; + overflow: hidden; + background-color: #e9e9e9; + /* Fallback */ + background-image: -webkit-linear-gradient(top, white 0%, #e9e9e9 100%); + /* Chrome 10+, Saf5.1+, iOS 5+ */ + background-image: -moz-linear-gradient(top, white 0%, #e9e9e9 100%); + /* FF3.6 */ + background-image: -ms-linear-gradient(top, white 0%, #e9e9e9 100%); + /* IE10 */ + background-image: -o-linear-gradient(top, white 0%, #e9e9e9 100%); + /* Opera 11.10+ */ + background-image: linear-gradient(to bottom, white 0%, #e9e9e9 100%); + filter: progid:DXImageTransform.Microsoft.gradient(GradientType=0,StartColorStr='white', EndColorStr='#e9e9e9'); + -webkit-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; + text-decoration: none; + outline: none; + text-overflow: ellipsis; +} +button.dt-button.disabled, +div.dt-button.disabled, +a.dt-button.disabled { + color: #999; + border: 1px solid #d0d0d0; + cursor: default; + background-color: #f9f9f9; + /* Fallback */ + background-image: -webkit-linear-gradient(top, #ffffff 0%, #f9f9f9 100%); + /* Chrome 10+, Saf5.1+, iOS 5+ */ + background-image: -moz-linear-gradient(top, #ffffff 0%, #f9f9f9 100%); + /* FF3.6 */ + background-image: -ms-linear-gradient(top, #ffffff 0%, #f9f9f9 100%); + /* IE10 */ + background-image: -o-linear-gradient(top, #ffffff 0%, #f9f9f9 100%); + /* Opera 11.10+ */ + background-image: linear-gradient(to bottom, #ffffff 0%, #f9f9f9 100%); + filter: progid:DXImageTransform.Microsoft.gradient(GradientType=0,StartColorStr='#ffffff', EndColorStr='#f9f9f9'); +} +button.dt-button:active:not(.disabled), button.dt-button.active:not(.disabled), +div.dt-button:active:not(.disabled), +div.dt-button.active:not(.disabled), +a.dt-button:active:not(.disabled), +a.dt-button.active:not(.disabled) { + background-color: #e2e2e2; + /* Fallback */ + background-image: -webkit-linear-gradient(top, #f3f3f3 0%, #e2e2e2 100%); + /* Chrome 10+, Saf5.1+, iOS 5+ */ + background-image: -moz-linear-gradient(top, #f3f3f3 0%, #e2e2e2 100%); + /* FF3.6 */ + background-image: -ms-linear-gradient(top, #f3f3f3 0%, #e2e2e2 100%); + /* IE10 */ + background-image: -o-linear-gradient(top, #f3f3f3 0%, #e2e2e2 100%); + /* Opera 11.10+ */ + background-image: linear-gradient(to bottom, #f3f3f3 0%, #e2e2e2 100%); + filter: progid:DXImageTransform.Microsoft.gradient(GradientType=0,StartColorStr='#f3f3f3', EndColorStr='#e2e2e2'); + box-shadow: inset 1px 1px 3px #999999; +} +button.dt-button:active:not(.disabled):hover:not(.disabled), button.dt-button.active:not(.disabled):hover:not(.disabled), +div.dt-button:active:not(.disabled):hover:not(.disabled), +div.dt-button.active:not(.disabled):hover:not(.disabled), +a.dt-button:active:not(.disabled):hover:not(.disabled), +a.dt-button.active:not(.disabled):hover:not(.disabled) { + box-shadow: inset 1px 1px 3px #999999; + background-color: #cccccc; + /* Fallback */ + background-image: -webkit-linear-gradient(top, #eaeaea 0%, #cccccc 100%); + /* Chrome 10+, Saf5.1+, iOS 5+ */ + background-image: -moz-linear-gradient(top, #eaeaea 0%, #cccccc 100%); + /* FF3.6 */ + background-image: -ms-linear-gradient(top, #eaeaea 0%, #cccccc 100%); + /* IE10 */ + background-image: -o-linear-gradient(top, #eaeaea 0%, #cccccc 100%); + /* Opera 11.10+ */ + background-image: linear-gradient(to bottom, #eaeaea 0%, #cccccc 100%); + filter: progid:DXImageTransform.Microsoft.gradient(GradientType=0,StartColorStr='#eaeaea', EndColorStr='#cccccc'); +} +button.dt-button:hover, +div.dt-button:hover, +a.dt-button:hover { + text-decoration: none; +} +button.dt-button:hover:not(.disabled), +div.dt-button:hover:not(.disabled), +a.dt-button:hover:not(.disabled) { + border: 1px solid #666; + background-color: #e0e0e0; + /* Fallback */ + background-image: -webkit-linear-gradient(top, #f9f9f9 0%, #e0e0e0 100%); + /* Chrome 10+, Saf5.1+, iOS 5+ */ + background-image: -moz-linear-gradient(top, #f9f9f9 0%, #e0e0e0 100%); + /* FF3.6 */ + background-image: -ms-linear-gradient(top, #f9f9f9 0%, #e0e0e0 100%); + /* IE10 */ + background-image: -o-linear-gradient(top, #f9f9f9 0%, #e0e0e0 100%); + /* Opera 11.10+ */ + background-image: linear-gradient(to bottom, #f9f9f9 0%, #e0e0e0 100%); + filter: progid:DXImageTransform.Microsoft.gradient(GradientType=0,StartColorStr='#f9f9f9', EndColorStr='#e0e0e0'); +} +button.dt-button:focus:not(.disabled), +div.dt-button:focus:not(.disabled), +a.dt-button:focus:not(.disabled) { + border: 1px solid #426c9e; + text-shadow: 0 1px 0 #c4def1; + outline: none; + background-color: #79ace9; + /* Fallback */ + background-image: -webkit-linear-gradient(top, #bddef4 0%, #79ace9 100%); + /* Chrome 10+, Saf5.1+, iOS 5+ */ + background-image: -moz-linear-gradient(top, #bddef4 0%, #79ace9 100%); + /* FF3.6 */ + background-image: -ms-linear-gradient(top, #bddef4 0%, #79ace9 100%); + /* IE10 */ + background-image: -o-linear-gradient(top, #bddef4 0%, #79ace9 100%); + /* Opera 11.10+ */ + background-image: linear-gradient(to bottom, #bddef4 0%, #79ace9 100%); + filter: progid:DXImageTransform.Microsoft.gradient(GradientType=0,StartColorStr='#bddef4', EndColorStr='#79ace9'); +} + +.dt-button embed { + outline: none; +} + +div.dt-buttons { + position: relative; + float: left; +} +div.dt-buttons.buttons-right { + float: right; +} + +div.dt-button-collection { + position: absolute; + top: 0; + left: 0; + width: 150px; + margin-top: 3px; + padding: 8px 8px 4px 8px; + border: 1px solid #ccc; + border: 1px solid rgba(0, 0, 0, 0.4); + background-color: white; + overflow: hidden; + z-index: 2002; + border-radius: 5px; + box-shadow: 3px 3px 5px rgba(0, 0, 0, 0.3); + box-sizing: border-box; +} +div.dt-button-collection button.dt-button, +div.dt-button-collection div.dt-button, +div.dt-button-collection a.dt-button { + position: relative; + left: 0; + right: 0; + width: 100%; + display: block; + float: none; + margin-bottom: 4px; + margin-right: 0; +} +div.dt-button-collection button.dt-button:active:not(.disabled), div.dt-button-collection button.dt-button.active:not(.disabled), +div.dt-button-collection div.dt-button:active:not(.disabled), +div.dt-button-collection div.dt-button.active:not(.disabled), +div.dt-button-collection a.dt-button:active:not(.disabled), +div.dt-button-collection a.dt-button.active:not(.disabled) { + background-color: #dadada; + /* Fallback */ + background-image: -webkit-linear-gradient(top, #f0f0f0 0%, #dadada 100%); + /* Chrome 10+, Saf5.1+, iOS 5+ */ + background-image: -moz-linear-gradient(top, #f0f0f0 0%, #dadada 100%); + /* FF3.6 */ + background-image: -ms-linear-gradient(top, #f0f0f0 0%, #dadada 100%); + /* IE10 */ + background-image: -o-linear-gradient(top, #f0f0f0 0%, #dadada 100%); + /* Opera 11.10+ */ + background-image: linear-gradient(to bottom, #f0f0f0 0%, #dadada 100%); + filter: progid:DXImageTransform.Microsoft.gradient(GradientType=0,StartColorStr='#f0f0f0', EndColorStr='#dadada'); + box-shadow: inset 1px 1px 3px #666; +} +div.dt-button-collection.fixed { + position: fixed; + top: 50%; + left: 50%; + margin-left: -75px; + border-radius: 0; +} +div.dt-button-collection.fixed.two-column { + margin-left: -200px; +} +div.dt-button-collection.fixed.three-column { + margin-left: -225px; +} +div.dt-button-collection.fixed.four-column { + margin-left: -300px; +} +div.dt-button-collection > :last-child { + display: block !important; + -webkit-column-gap: 8px; + -moz-column-gap: 8px; + -ms-column-gap: 8px; + -o-column-gap: 8px; + column-gap: 8px; +} +div.dt-button-collection > :last-child > * { + -webkit-column-break-inside: avoid; + break-inside: avoid; +} +div.dt-button-collection.two-column { + width: 400px; +} +div.dt-button-collection.two-column > :last-child { + padding-bottom: 1px; + -webkit-column-count: 2; + -moz-column-count: 2; + -ms-column-count: 2; + -o-column-count: 2; + column-count: 2; +} +div.dt-button-collection.three-column { + width: 450px; +} +div.dt-button-collection.three-column > :last-child { + padding-bottom: 1px; + -webkit-column-count: 3; + -moz-column-count: 3; + -ms-column-count: 3; + -o-column-count: 3; + column-count: 3; +} +div.dt-button-collection.four-column { + width: 600px; +} +div.dt-button-collection.four-column > :last-child { + padding-bottom: 1px; + -webkit-column-count: 4; + -moz-column-count: 4; + -ms-column-count: 4; + -o-column-count: 4; + column-count: 4; +} +div.dt-button-collection .dt-button { + border-radius: 0; +} + +div.dt-button-background { + position: fixed; + top: 0; + left: 0; + width: 100%; + height: 100%; + background: rgba(0, 0, 0, 0.7); + /* Fallback */ + background: -ms-radial-gradient(center, ellipse farthest-corner, rgba(0, 0, 0, 0.3) 0%, rgba(0, 0, 0, 0.7) 100%); + /* IE10 Consumer Preview */ + background: -moz-radial-gradient(center, ellipse farthest-corner, rgba(0, 0, 0, 0.3) 0%, rgba(0, 0, 0, 0.7) 100%); + /* Firefox */ + background: -o-radial-gradient(center, ellipse farthest-corner, rgba(0, 0, 0, 0.3) 0%, rgba(0, 0, 0, 0.7) 100%); + /* Opera */ + background: -webkit-gradient(radial, center center, 0, center center, 497, color-stop(0, rgba(0, 0, 0, 0.3)), color-stop(1, rgba(0, 0, 0, 0.7))); + /* Webkit (Safari/Chrome 10) */ + background: -webkit-radial-gradient(center, ellipse farthest-corner, rgba(0, 0, 0, 0.3) 0%, rgba(0, 0, 0, 0.7) 100%); + /* Webkit (Chrome 11+) */ + background: radial-gradient(ellipse farthest-corner at center, rgba(0, 0, 0, 0.3) 0%, rgba(0, 0, 0, 0.7) 100%); + /* W3C Markup, IE10 Release Preview */ + z-index: 2001; +} + +@media screen and (max-width: 640px) { + div.dt-buttons { + float: none !important; + text-align: center; + } +} +button.dt-button.processing, +div.dt-button.processing, +a.dt-button.processing { + color: rgba(0, 0, 0, 0.2); +} +button.dt-button.processing:after, +div.dt-button.processing:after, +a.dt-button.processing:after { + position: absolute; + top: 50%; + left: 50%; + width: 16px; + height: 16px; + margin: -8px 0 0 -8px; + box-sizing: border-box; + display: block; + content: ' '; + border: 2px solid #282828; + border-radius: 50%; + border-left-color: transparent; + border-right-color: transparent; + animation: dtb-spinner 1500ms infinite linear; + -o-animation: dtb-spinner 1500ms infinite linear; + -ms-animation: dtb-spinner 1500ms infinite linear; + -webkit-animation: dtb-spinner 1500ms infinite linear; + -moz-animation: dtb-spinner 1500ms infinite linear; +} diff --git a/helpdesk/static/helpdesk/vendor/datatables/js/buttons.colVis.js b/helpdesk/static/helpdesk/vendor/datatables/js/buttons.colVis.js new file mode 100644 index 00000000..b9529d29 --- /dev/null +++ b/helpdesk/static/helpdesk/vendor/datatables/js/buttons.colVis.js @@ -0,0 +1,206 @@ +/*! + * Column visibility buttons for Buttons and DataTables. + * 2016 SpryMedia Ltd - datatables.net/license + */ + +(function( factory ){ + if ( typeof define === 'function' && define.amd ) { + // AMD + define( ['jquery', 'datatables.net', 'datatables.net-buttons'], function ( $ ) { + return factory( $, window, document ); + } ); + } + else if ( typeof exports === 'object' ) { + // CommonJS + module.exports = function (root, $) { + if ( ! root ) { + root = window; + } + + if ( ! $ || ! $.fn.dataTable ) { + $ = require('datatables.net')(root, $).$; + } + + if ( ! $.fn.dataTable.Buttons ) { + require('datatables.net-buttons')(root, $); + } + + return factory( $, root, root.document ); + }; + } + else { + // Browser + factory( jQuery, window, document ); + } +}(function( $, window, document, undefined ) { +'use strict'; +var DataTable = $.fn.dataTable; + + +$.extend( DataTable.ext.buttons, { + // A collection of column visibility buttons + colvis: function ( dt, conf ) { + return { + extend: 'collection', + text: function ( dt ) { + return dt.i18n( 'buttons.colvis', 'Column visibility' ); + }, + className: 'buttons-colvis', + buttons: [ { + extend: 'columnsToggle', + columns: conf.columns, + columnText: conf.columnText + } ] + }; + }, + + // Selected columns with individual buttons - toggle column visibility + columnsToggle: function ( dt, conf ) { + var columns = dt.columns( conf.columns ).indexes().map( function ( idx ) { + return { + extend: 'columnToggle', + columns: idx, + columnText: conf.columnText + }; + } ).toArray(); + + return columns; + }, + + // Single button to toggle column visibility + columnToggle: function ( dt, conf ) { + return { + extend: 'columnVisibility', + columns: conf.columns, + columnText: conf.columnText + }; + }, + + // Selected columns with individual buttons - set column visibility + columnsVisibility: function ( dt, conf ) { + var columns = dt.columns( conf.columns ).indexes().map( function ( idx ) { + return { + extend: 'columnVisibility', + columns: idx, + visibility: conf.visibility, + columnText: conf.columnText + }; + } ).toArray(); + + return columns; + }, + + // Single button to set column visibility + columnVisibility: { + columns: undefined, // column selector + text: function ( dt, button, conf ) { + return conf._columnText( dt, conf ); + }, + className: 'buttons-columnVisibility', + action: function ( e, dt, button, conf ) { + var col = dt.columns( conf.columns ); + var curr = col.visible(); + + col.visible( conf.visibility !== undefined ? + conf.visibility : + ! (curr.length ? curr[0] : false ) + ); + }, + init: function ( dt, button, conf ) { + var that = this; + button.attr( 'data-cv-idx', conf.columns ); + + dt + .on( 'column-visibility.dt'+conf.namespace, function (e, settings) { + if ( ! settings.bDestroying && settings.nTable == dt.settings()[0].nTable ) { + that.active( dt.column( conf.columns ).visible() ); + } + } ) + .on( 'column-reorder.dt'+conf.namespace, function (e, settings, details) { + if ( dt.columns( conf.columns ).count() !== 1 ) { + return; + } + + // This button controls the same column index but the text for the column has + // changed + button.text( conf._columnText( dt, conf ) ); + + // Since its a different column, we need to check its visibility + that.active( dt.column( conf.columns ).visible() ); + } ); + + this.active( dt.column( conf.columns ).visible() ); + }, + destroy: function ( dt, button, conf ) { + dt + .off( 'column-visibility.dt'+conf.namespace ) + .off( 'column-reorder.dt'+conf.namespace ); + }, + + _columnText: function ( dt, conf ) { + // Use DataTables' internal data structure until this is presented + // is a public API. The other option is to use + // `$( column(col).node() ).text()` but the node might not have been + // populated when Buttons is constructed. + var idx = dt.column( conf.columns ).index(); + var title = dt.settings()[0].aoColumns[ idx ].sTitle + .replace(/\n/g," ") // remove new lines + .replace(//gi, " ") // replace line breaks with spaces + .replace(//g, "") // remove select tags, including options text + .replace(//g, "") // strip HTML comments + .replace(/<.*?>/g, "") // strip HTML + .replace(/^\s+|\s+$/g,""); // trim + + return conf.columnText ? + conf.columnText( dt, idx, title ) : + title; + } + }, + + + colvisRestore: { + className: 'buttons-colvisRestore', + + text: function ( dt ) { + return dt.i18n( 'buttons.colvisRestore', 'Restore visibility' ); + }, + + init: function ( dt, button, conf ) { + conf._visOriginal = dt.columns().indexes().map( function ( idx ) { + return dt.column( idx ).visible(); + } ).toArray(); + }, + + action: function ( e, dt, button, conf ) { + dt.columns().every( function ( i ) { + // Take into account that ColReorder might have disrupted our + // indexes + var idx = dt.colReorder && dt.colReorder.transpose ? + dt.colReorder.transpose( i, 'toOriginal' ) : + i; + + this.visible( conf._visOriginal[ idx ] ); + } ); + } + }, + + + colvisGroup: { + className: 'buttons-colvisGroup', + + action: function ( e, dt, button, conf ) { + dt.columns( conf.show ).visible( true, false ); + dt.columns( conf.hide ).visible( false, false ); + + dt.columns.adjust(); + }, + + show: [], + + hide: [] + } +} ); + + +return DataTable.Buttons; +})); diff --git a/helpdesk/static/helpdesk/vendor/datatables/js/dataTables.buttons.js b/helpdesk/static/helpdesk/vendor/datatables/js/dataTables.buttons.js new file mode 100644 index 00000000..045bb8ce --- /dev/null +++ b/helpdesk/static/helpdesk/vendor/datatables/js/dataTables.buttons.js @@ -0,0 +1,2015 @@ +/*! Buttons for DataTables 1.6.1 + * ©2016-2019 SpryMedia Ltd - datatables.net/license + */ + +(function( factory ){ + if ( typeof define === 'function' && define.amd ) { + // AMD + define( ['jquery', 'datatables.net'], function ( $ ) { + return factory( $, window, document ); + } ); + } + else if ( typeof exports === 'object' ) { + // CommonJS + module.exports = function (root, $) { + if ( ! root ) { + root = window; + } + + if ( ! $ || ! $.fn.dataTable ) { + $ = require('datatables.net')(root, $).$; + } + + return factory( $, root, root.document ); + }; + } + else { + // Browser + factory( jQuery, window, document ); + } +}(function( $, window, document, undefined ) { +'use strict'; +var DataTable = $.fn.dataTable; + + +// Used for namespacing events added to the document by each instance, so they +// can be removed on destroy +var _instCounter = 0; + +// Button namespacing counter for namespacing events on individual buttons +var _buttonCounter = 0; + +var _dtButtons = DataTable.ext.buttons; + +/** + * [Buttons description] + * @param {[type]} + * @param {[type]} + */ +var Buttons = function( dt, config ) +{ + // If not created with a `new` keyword then we return a wrapper function that + // will take the settings object for a DT. This allows easy use of new instances + // with the `layout` option - e.g. `topLeft: $.fn.dataTable.Buttons( ... )`. + if ( !(this instanceof Buttons) ) { + return function (settings) { + return new Buttons( settings, dt ).container(); + }; + } + + // If there is no config set it to an empty object + if ( typeof( config ) === 'undefined' ) { + config = {}; + } + + // Allow a boolean true for defaults + if ( config === true ) { + config = {}; + } + + // For easy configuration of buttons an array can be given + if ( $.isArray( config ) ) { + config = { buttons: config }; + } + + this.c = $.extend( true, {}, Buttons.defaults, config ); + + // Don't want a deep copy for the buttons + if ( config.buttons ) { + this.c.buttons = config.buttons; + } + + this.s = { + dt: new DataTable.Api( dt ), + buttons: [], + listenKeys: '', + namespace: 'dtb'+(_instCounter++) + }; + + this.dom = { + container: $('<'+this.c.dom.container.tag+'/>') + .addClass( this.c.dom.container.className ) + }; + + this._constructor(); +}; + + +$.extend( Buttons.prototype, { + /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * Public methods + */ + + /** + * Get the action of a button + * @param {int|string} Button index + * @return {function} + *//** + * Set the action of a button + * @param {node} node Button element + * @param {function} action Function to set + * @return {Buttons} Self for chaining + */ + action: function ( node, action ) + { + var button = this._nodeToButton( node ); + + if ( action === undefined ) { + return button.conf.action; + } + + button.conf.action = action; + + return this; + }, + + /** + * Add an active class to the button to make to look active or get current + * active state. + * @param {node} node Button element + * @param {boolean} [flag] Enable / disable flag + * @return {Buttons} Self for chaining or boolean for getter + */ + active: function ( node, flag ) { + var button = this._nodeToButton( node ); + var klass = this.c.dom.button.active; + var jqNode = $(button.node); + + if ( flag === undefined ) { + return jqNode.hasClass( klass ); + } + + jqNode.toggleClass( klass, flag === undefined ? true : flag ); + + return this; + }, + + /** + * Add a new button + * @param {object} config Button configuration object, base string name or function + * @param {int|string} [idx] Button index for where to insert the button + * @return {Buttons} Self for chaining + */ + add: function ( config, idx ) + { + var buttons = this.s.buttons; + + if ( typeof idx === 'string' ) { + var split = idx.split('-'); + var base = this.s; + + for ( var i=0, ien=split.length-1 ; i=0 ; i-- ) { + this.remove( button.buttons[i].node ); + } + } + + // Allow the button to remove event handlers, etc + if ( button.conf.destroy ) { + button.conf.destroy.call( dt.button(node), dt, $(node), button.conf ); + } + + this._removeKey( button.conf ); + + $(button.node).remove(); + + var idx = $.inArray( button, host ); + host.splice( idx, 1 ); + + return this; + }, + + /** + * Get the text for a button + * @param {int|string} node Button index + * @return {string} Button text + *//** + * Set the text for a button + * @param {int|string|function} node Button index + * @param {string} label Text + * @return {Buttons} Self for chaining + */ + text: function ( node, label ) + { + var button = this._nodeToButton( node ); + var buttonLiner = this.c.dom.collection.buttonLiner; + var linerTag = button.inCollection && buttonLiner && buttonLiner.tag ? + buttonLiner.tag : + this.c.dom.buttonLiner.tag; + var dt = this.s.dt; + var jqNode = $(button.node); + var text = function ( opt ) { + return typeof opt === 'function' ? + opt( dt, jqNode, button.conf ) : + opt; + }; + + if ( label === undefined ) { + return text( button.conf.text ); + } + + button.conf.text = label; + + if ( linerTag ) { + jqNode.children( linerTag ).html( text(label) ); + } + else { + jqNode.html( text(label) ); + } + + return this; + }, + + + /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * Constructor + */ + + /** + * Buttons constructor + * @private + */ + _constructor: function () + { + var that = this; + var dt = this.s.dt; + var dtSettings = dt.settings()[0]; + var buttons = this.c.buttons; + + if ( ! dtSettings._buttons ) { + dtSettings._buttons = []; + } + + dtSettings._buttons.push( { + inst: this, + name: this.c.name + } ); + + for ( var i=0, ien=buttons.length ; i'); + + built.conf._collection = built.collection; + + this._expandButton( built.buttons, built.conf.buttons, true, attachPoint ); + } + + // init call is made here, rather than buildButton as it needs to + // be selectable, and for that it needs to be in the buttons array + if ( conf.init ) { + conf.init.call( dt.button( built.node ), dt, $(built.node), conf ); + } + + buttonCounter++; + } + }, + + /** + * Create an individual button + * @param {object} config Resolved button configuration + * @param {boolean} inCollection `true` if a collection button + * @return {jQuery} Created button node (jQuery) + * @private + */ + _buildButton: function ( config, inCollection ) + { + var buttonDom = this.c.dom.button; + var linerDom = this.c.dom.buttonLiner; + var collectionDom = this.c.dom.collection; + var dt = this.s.dt; + var text = function ( opt ) { + return typeof opt === 'function' ? + opt( dt, button, config ) : + opt; + }; + + if ( inCollection && collectionDom.button ) { + buttonDom = collectionDom.button; + } + + if ( inCollection && collectionDom.buttonLiner ) { + linerDom = collectionDom.buttonLiner; + } + + // Make sure that the button is available based on whatever requirements + // it has. For example, Flash buttons require Flash + if ( config.available && ! config.available( dt, config ) ) { + return false; + } + + var action = function ( e, dt, button, config ) { + config.action.call( dt.button( button ), e, dt, button, config ); + + $(dt.table().node()).triggerHandler( 'buttons-action.dt', [ + dt.button( button ), dt, button, config + ] ); + }; + + var tag = config.tag || buttonDom.tag; + var clickBlurs = config.clickBlurs === undefined ? true : config.clickBlurs + var button = $('<'+tag+'/>') + .addClass( buttonDom.className ) + .attr( 'tabindex', this.s.dt.settings()[0].iTabIndex ) + .attr( 'aria-controls', this.s.dt.table().node().id ) + .on( 'click.dtb', function (e) { + e.preventDefault(); + + if ( ! button.hasClass( buttonDom.disabled ) && config.action ) { + action( e, dt, button, config ); + } + if( clickBlurs ) { + button.blur(); + } + } ) + .on( 'keyup.dtb', function (e) { + if ( e.keyCode === 13 ) { + if ( ! button.hasClass( buttonDom.disabled ) && config.action ) { + action( e, dt, button, config ); + } + } + } ); + + // Make `a` tags act like a link + if ( tag.toLowerCase() === 'a' ) { + button.attr( 'href', '#' ); + } + + // Button tags should have `type=button` so they don't have any default behaviour + if ( tag.toLowerCase() === 'button' ) { + button.attr( 'type', 'button' ); + } + + if ( linerDom.tag ) { + var liner = $('<'+linerDom.tag+'/>') + .html( text( config.text ) ) + .addClass( linerDom.className ); + + if ( linerDom.tag.toLowerCase() === 'a' ) { + liner.attr( 'href', '#' ); + } + + button.append( liner ); + } + else { + button.html( text( config.text ) ); + } + + if ( config.enabled === false ) { + button.addClass( buttonDom.disabled ); + } + + if ( config.className ) { + button.addClass( config.className ); + } + + if ( config.titleAttr ) { + button.attr( 'title', text( config.titleAttr ) ); + } + + if ( config.attr ) { + button.attr( config.attr ); + } + + if ( ! config.namespace ) { + config.namespace = '.dt-button-'+(_buttonCounter++); + } + + var buttonContainer = this.c.dom.buttonContainer; + var inserter; + if ( buttonContainer && buttonContainer.tag ) { + inserter = $('<'+buttonContainer.tag+'/>') + .addClass( buttonContainer.className ) + .append( button ); + } + else { + inserter = button; + } + + this._addKey( config ); + + // Style integration callback for DOM manipulation + // Note that this is _not_ documented. It is currently + // for style integration only + if( this.c.buttonCreated ) { + inserter = this.c.buttonCreated( config, inserter ); + } + + return { + conf: config, + node: button.get(0), + inserter: inserter, + buttons: [], + inCollection: inCollection, + collection: null + }; + }, + + /** + * Get the button object from a node (recursive) + * @param {node} node Button node + * @param {array} [buttons] Button array, uses base if not defined + * @return {object} Button object + * @private + */ + _nodeToButton: function ( node, buttons ) + { + if ( ! buttons ) { + buttons = this.s.buttons; + } + + for ( var i=0, ien=buttons.length ; i 30 ) { + // Protect against misconfiguration killing the browser + throw 'Buttons: Too many iterations'; + } + } + + return $.isArray( base ) ? + base : + $.extend( {}, base ); + }; + + conf = toConfObject( conf ); + + while ( conf && conf.extend ) { + // Use `toConfObject` in case the button definition being extended + // is itself a string or a function + if ( ! _dtButtons[ conf.extend ] ) { + throw 'Cannot extend unknown button type: '+conf.extend; + } + + var objArray = toConfObject( _dtButtons[ conf.extend ] ); + if ( $.isArray( objArray ) ) { + return objArray; + } + else if ( ! objArray ) { + // This is a little brutal as it might be possible to have a + // valid button without the extend, but if there is no extend + // then the host button would be acting in an undefined state + return false; + } + + // Stash the current class name + var originalClassName = objArray.className; + + conf = $.extend( {}, objArray, conf ); + + // The extend will have overwritten the original class name if the + // `conf` object also assigned a class, but we want to concatenate + // them so they are list that is combined from all extended buttons + if ( originalClassName && conf.className !== originalClassName ) { + conf.className = originalClassName+' '+conf.className; + } + + // Buttons to be added to a collection -gives the ability to define + // if buttons should be added to the start or end of a collection + var postfixButtons = conf.postfixButtons; + if ( postfixButtons ) { + if ( ! conf.buttons ) { + conf.buttons = []; + } + + for ( i=0, ien=postfixButtons.length ; i') + .addClass('dt-button-collection') + .addClass(options.collectionLayout) + .css('display', 'none'); + + content = $(content) + .addClass(options.contentClassName) + .attr('role', 'menu') + .appendTo(display); + + hostNode.attr( 'aria-expanded', 'true' ); + + if ( hostNode.parents('body')[0] !== document.body ) { + hostNode = document.body.lastChild; + } + + if ( options.collectionTitle ) { + display.prepend('
'+options.collectionTitle+'
'); + } + + display + .insertAfter( hostNode ) + .fadeIn( options.fade ); + + var tableContainer = $( hostButton.table().container() ); + var position = display.css( 'position' ); + + if ( options.align === 'dt-container' ) { + hostNode = hostNode.parent(); + display.css('width', tableContainer.width()); + } + + if ( position === 'absolute' ) { + var hostPosition = hostNode.position(); + + display.css( { + top: hostPosition.top + hostNode.outerHeight(), + left: hostPosition.left + } ); + + // calculate overflow when positioned beneath + var collectionHeight = display.outerHeight(); + var collectionWidth = display.outerWidth(); + var tableBottom = tableContainer.offset().top + tableContainer.height(); + var listBottom = hostPosition.top + hostNode.outerHeight() + collectionHeight; + var bottomOverflow = listBottom - tableBottom; + + // calculate overflow when positioned above + var listTop = hostPosition.top - collectionHeight; + var tableTop = tableContainer.offset().top; + var topOverflow = tableTop - listTop; + + // if bottom overflow is larger, move to the top because it fits better, or if dropup is requested + var moveTop = hostPosition.top - collectionHeight - 5; + if ( (bottomOverflow > topOverflow || options.dropup) && -moveTop < tableTop ) { + display.css( 'top', moveTop); + } + + // Right alignment is enabled on a class, e.g. bootstrap: + // $.fn.dataTable.Buttons.defaults.dom.collection.className += " dropdown-menu-right"; + if ( display.hasClass( options.rightAlignClassName ) || options.align === 'button-right' ) { + display.css( 'left', hostPosition.left + hostNode.outerWidth() - collectionWidth ); + } + + // Right alignment in table container + var listRight = hostPosition.left + collectionWidth; + var tableRight = tableContainer.offset().left + tableContainer.width(); + if ( listRight > tableRight ) { + display.css( 'left', hostPosition.left - ( listRight - tableRight ) ); + } + + // Right alignment to window + var listOffsetRight = hostNode.offset().left + collectionWidth; + if ( listOffsetRight > $(window).width() ) { + display.css( 'left', hostPosition.left - (listOffsetRight-$(window).width()) ); + } + } + else { + // Fix position - centre on screen + var top = display.height() / 2; + if ( top > $(window).height() / 2 ) { + top = $(window).height() / 2; + } + + display.css( 'marginTop', top*-1 ); + } + + if ( options.background ) { + Buttons.background( true, options.backgroundClassName, options.fade, hostNode ); + } + + // This is bonkers, but if we don't have a click listener on the + // background element, iOS Safari will ignore the body click + // listener below. An empty function here is all that is + // required to make it work... + $('div.dt-button-background').on( 'click.dtb-collection', function () {} ); + + $('body') + .on( 'click.dtb-collection', function (e) { + // andSelf is deprecated in jQ1.8, but we want 1.7 compat + var back = $.fn.addBack ? 'addBack' : 'andSelf'; + + if ( ! $(e.target).parents()[back]().filter( content ).length ) { + close(); + } + } ) + .on( 'keyup.dtb-collection', function (e) { + if ( e.keyCode === 27 ) { + close(); + } + } ); + + if ( options.autoClose ) { + setTimeout( function () { + dt.on( 'buttons-action.b-internal', function (e, btn, dt, node) { + if ( node[0] === hostNode[0] ) { + return; + } + close(); + } ); + }, 0); + } + } +} ); + + + +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * Statics + */ + +/** + * Show / hide a background layer behind a collection + * @param {boolean} Flag to indicate if the background should be shown or + * hidden + * @param {string} Class to assign to the background + * @static + */ +Buttons.background = function ( show, className, fade, insertPoint ) { + if ( fade === undefined ) { + fade = 400; + } + if ( ! insertPoint ) { + insertPoint = document.body; + } + + if ( show ) { + $('
') + .addClass( className ) + .css( 'display', 'none' ) + .insertAfter( insertPoint ) + .stop() + .fadeIn( fade ); + } + else { + $('div.'+className) + .stop() + .fadeOut( fade, function () { + $(this) + .removeClass( className ) + .remove(); + } ); + } +}; + +/** + * Instance selector - select Buttons instances based on an instance selector + * value from the buttons assigned to a DataTable. This is only useful if + * multiple instances are attached to a DataTable. + * @param {string|int|array} Instance selector - see `instance-selector` + * documentation on the DataTables site + * @param {array} Button instance array that was attached to the DataTables + * settings object + * @return {array} Buttons instances + * @static + */ +Buttons.instanceSelector = function ( group, buttons ) +{ + if ( group === undefined || group === null ) { + return $.map( buttons, function ( v ) { + return v.inst; + } ); + } + + var ret = []; + var names = $.map( buttons, function ( v ) { + return v.name; + } ); + + // Flatten the group selector into an array of single options + var process = function ( input ) { + if ( $.isArray( input ) ) { + for ( var i=0, ien=input.length ; i` in IE - it has to be `` + tag: 'ActiveXObject' in window ? + 'a' : + 'button', + className: 'dt-button', + active: 'active', + disabled: 'disabled' + }, + buttonLiner: { + tag: 'span', + className: '' + } + } +}; + +/** + * Version information + * @type {string} + * @static + */ +Buttons.version = '1.6.1'; + + +$.extend( _dtButtons, { + collection: { + text: function ( dt ) { + return dt.i18n( 'buttons.collection', 'Collection' ); + }, + className: 'buttons-collection', + init: function ( dt, button, config ) { + button.attr( 'aria-expanded', false ); + }, + action: function ( e, dt, button, config ) { + e.stopPropagation(); + + if ( config._collection.parents('body').length ) { + this.popover(false, config); + } + else { + this.popover(config._collection, config); + } + }, + attr: { + 'aria-haspopup': true + } + // Also the popover options, defined in Buttons.popover + }, + copy: function ( dt, conf ) { + if ( _dtButtons.copyHtml5 ) { + return 'copyHtml5'; + } + if ( _dtButtons.copyFlash && _dtButtons.copyFlash.available( dt, conf ) ) { + return 'copyFlash'; + } + }, + csv: function ( dt, conf ) { + // Common option that will use the HTML5 or Flash export buttons + if ( _dtButtons.csvHtml5 && _dtButtons.csvHtml5.available( dt, conf ) ) { + return 'csvHtml5'; + } + if ( _dtButtons.csvFlash && _dtButtons.csvFlash.available( dt, conf ) ) { + return 'csvFlash'; + } + }, + excel: function ( dt, conf ) { + // Common option that will use the HTML5 or Flash export buttons + if ( _dtButtons.excelHtml5 && _dtButtons.excelHtml5.available( dt, conf ) ) { + return 'excelHtml5'; + } + if ( _dtButtons.excelFlash && _dtButtons.excelFlash.available( dt, conf ) ) { + return 'excelFlash'; + } + }, + pdf: function ( dt, conf ) { + // Common option that will use the HTML5 or Flash export buttons + if ( _dtButtons.pdfHtml5 && _dtButtons.pdfHtml5.available( dt, conf ) ) { + return 'pdfHtml5'; + } + if ( _dtButtons.pdfFlash && _dtButtons.pdfFlash.available( dt, conf ) ) { + return 'pdfFlash'; + } + }, + pageLength: function ( dt ) { + var lengthMenu = dt.settings()[0].aLengthMenu; + var vals = $.isArray( lengthMenu[0] ) ? lengthMenu[0] : lengthMenu; + var lang = $.isArray( lengthMenu[0] ) ? lengthMenu[1] : lengthMenu; + var text = function ( dt ) { + return dt.i18n( 'buttons.pageLength', { + "-1": 'Show all rows', + _: 'Show %d rows' + }, dt.page.len() ); + }; + + return { + extend: 'collection', + text: text, + className: 'buttons-page-length', + autoClose: true, + buttons: $.map( vals, function ( val, i ) { + return { + text: lang[i], + className: 'button-page-length', + action: function ( e, dt ) { + dt.page.len( val ).draw(); + }, + init: function ( dt, node, conf ) { + var that = this; + var fn = function () { + that.active( dt.page.len() === val ); + }; + + dt.on( 'length.dt'+conf.namespace, fn ); + fn(); + }, + destroy: function ( dt, node, conf ) { + dt.off( 'length.dt'+conf.namespace ); + } + }; + } ), + init: function ( dt, node, conf ) { + var that = this; + dt.on( 'length.dt'+conf.namespace, function () { + that.text( conf.text ); + } ); + }, + destroy: function ( dt, node, conf ) { + dt.off( 'length.dt'+conf.namespace ); + } + }; + } +} ); + + +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * DataTables API + * + * For complete documentation, please refer to the docs/api directory or the + * DataTables site + */ + +// Buttons group and individual button selector +DataTable.Api.register( 'buttons()', function ( group, selector ) { + // Argument shifting + if ( selector === undefined ) { + selector = group; + group = undefined; + } + + this.selector.buttonGroup = group; + + var res = this.iterator( true, 'table', function ( ctx ) { + if ( ctx._buttons ) { + return Buttons.buttonSelector( + Buttons.instanceSelector( group, ctx._buttons ), + selector + ); + } + }, true ); + + res._groupSelector = group; + return res; +} ); + +// Individual button selector +DataTable.Api.register( 'button()', function ( group, selector ) { + // just run buttons() and truncate + var buttons = this.buttons( group, selector ); + + if ( buttons.length > 1 ) { + buttons.splice( 1, buttons.length ); + } + + return buttons; +} ); + +// Active buttons +DataTable.Api.registerPlural( 'buttons().active()', 'button().active()', function ( flag ) { + if ( flag === undefined ) { + return this.map( function ( set ) { + return set.inst.active( set.node ); + } ); + } + + return this.each( function ( set ) { + set.inst.active( set.node, flag ); + } ); +} ); + +// Get / set button action +DataTable.Api.registerPlural( 'buttons().action()', 'button().action()', function ( action ) { + if ( action === undefined ) { + return this.map( function ( set ) { + return set.inst.action( set.node ); + } ); + } + + return this.each( function ( set ) { + set.inst.action( set.node, action ); + } ); +} ); + +// Enable / disable buttons +DataTable.Api.register( ['buttons().enable()', 'button().enable()'], function ( flag ) { + return this.each( function ( set ) { + set.inst.enable( set.node, flag ); + } ); +} ); + +// Disable buttons +DataTable.Api.register( ['buttons().disable()', 'button().disable()'], function () { + return this.each( function ( set ) { + set.inst.disable( set.node ); + } ); +} ); + +// Get button nodes +DataTable.Api.registerPlural( 'buttons().nodes()', 'button().node()', function () { + var jq = $(); + + // jQuery will automatically reduce duplicates to a single entry + $( this.each( function ( set ) { + jq = jq.add( set.inst.node( set.node ) ); + } ) ); + + return jq; +} ); + +// Get / set button processing state +DataTable.Api.registerPlural( 'buttons().processing()', 'button().processing()', function ( flag ) { + if ( flag === undefined ) { + return this.map( function ( set ) { + return set.inst.processing( set.node ); + } ); + } + + return this.each( function ( set ) { + set.inst.processing( set.node, flag ); + } ); +} ); + +// Get / set button text (i.e. the button labels) +DataTable.Api.registerPlural( 'buttons().text()', 'button().text()', function ( label ) { + if ( label === undefined ) { + return this.map( function ( set ) { + return set.inst.text( set.node ); + } ); + } + + return this.each( function ( set ) { + set.inst.text( set.node, label ); + } ); +} ); + +// Trigger a button's action +DataTable.Api.registerPlural( 'buttons().trigger()', 'button().trigger()', function () { + return this.each( function ( set ) { + set.inst.node( set.node ).trigger( 'click' ); + } ); +} ); + +// Button resolver to the popover +DataTable.Api.register( 'button().popover()', function (content, options) { + return this.map( function ( set ) { + return set.inst._popover( content, this.button(this[0].node), options ); + } ); +} ); + +// Get the container elements +DataTable.Api.register( 'buttons().containers()', function () { + var jq = $(); + var groupSelector = this._groupSelector; + + // We need to use the group selector directly, since if there are no buttons + // the result set will be empty + this.iterator( true, 'table', function ( ctx ) { + if ( ctx._buttons ) { + var insts = Buttons.instanceSelector( groupSelector, ctx._buttons ); + + for ( var i=0, ien=insts.length ; i'+title+'' : ''; + + $('
') + .html( title ) + .append( $('
')[ typeof message === 'string' ? 'html' : 'append' ]( message ) ) + .css( 'display', 'none' ) + .appendTo( 'body' ) + .fadeIn(); + + if ( time !== undefined && time !== 0 ) { + _infoTimer = setTimeout( function () { + that.buttons.info( false ); + }, time ); + } + + this.on('destroy.btn-info', function () { + that.buttons.info(false); + }); + + return this; +} ); + +// Get data from the table for export - this is common to a number of plug-in +// buttons so it is included in the Buttons core library +DataTable.Api.register( 'buttons.exportData()', function ( options ) { + if ( this.context.length ) { + return _exportData( new DataTable.Api( this.context[0] ), options ); + } +} ); + +// Get information about the export that is common to many of the export data +// types (DRY) +DataTable.Api.register( 'buttons.exportInfo()', function ( conf ) { + if ( ! conf ) { + conf = {}; + } + + return { + filename: _filename( conf ), + title: _title( conf ), + messageTop: _message(this, conf.message || conf.messageTop, 'top'), + messageBottom: _message(this, conf.messageBottom, 'bottom') + }; +} ); + + + +/** + * Get the file name for an exported file. + * + * @param {object} config Button configuration + * @param {boolean} incExtension Include the file name extension + */ +var _filename = function ( config ) +{ + // Backwards compatibility + var filename = config.filename === '*' && config.title !== '*' && config.title !== undefined && config.title !== null && config.title !== '' ? + config.title : + config.filename; + + if ( typeof filename === 'function' ) { + filename = filename(); + } + + if ( filename === undefined || filename === null ) { + return null; + } + + if ( filename.indexOf( '*' ) !== -1 ) { + filename = $.trim( filename.replace( '*', $('head > title').text() ) ); + } + + // Strip characters which the OS will object to + filename = filename.replace(/[^a-zA-Z0-9_\u00A1-\uFFFF\.,\-_ !\(\)]/g, ""); + + var extension = _stringOrFunction( config.extension ); + if ( ! extension ) { + extension = ''; + } + + return filename + extension; +}; + +/** + * Simply utility method to allow parameters to be given as a function + * + * @param {undefined|string|function} option Option + * @return {null|string} Resolved value + */ +var _stringOrFunction = function ( option ) +{ + if ( option === null || option === undefined ) { + return null; + } + else if ( typeof option === 'function' ) { + return option(); + } + return option; +}; + +/** + * Get the title for an exported file. + * + * @param {object} config Button configuration + */ +var _title = function ( config ) +{ + var title = _stringOrFunction( config.title ); + + return title === null ? + null : title.indexOf( '*' ) !== -1 ? + title.replace( '*', $('head > title').text() || 'Exported data' ) : + title; +}; + +var _message = function ( dt, option, position ) +{ + var message = _stringOrFunction( option ); + if ( message === null ) { + return null; + } + + var caption = $('caption', dt.table().container()).eq(0); + if ( message === '*' ) { + var side = caption.css( 'caption-side' ); + if ( side !== position ) { + return null; + } + + return caption.length ? + caption.text() : + ''; + } + + return message; +}; + + + + + + + +var _exportTextarea = $('