You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4376 lines
157 KiB
4376 lines
157 KiB
(function () { |
|
'use strict'; |
|
|
|
/*! DateTime picker for DataTables.net v1.0.1 |
|
* |
|
* ©2020 SpryMedia Ltd, all rights reserved. |
|
* License: MIT datatables.net/license/mit |
|
*/ |
|
|
|
/** |
|
* @summary DateTime picker for DataTables.net |
|
* @version 1.0.1 |
|
* @file dataTables.dateTime.js |
|
* @author SpryMedia Ltd |
|
* @contact www.datatables.net/contact |
|
*/ |
|
(function( factory ){ |
|
if ( typeof define === 'function' && define.amd ) { |
|
// AMD |
|
define( ['jquery'], function ( $ ) { |
|
return factory( $, window, document ); |
|
} ); |
|
} |
|
else if ( typeof exports === 'object' ) { |
|
// CommonJS |
|
module.exports = function (root, $) { |
|
if ( ! root ) { |
|
root = window; |
|
} |
|
|
|
return factory( $, root, root.document ); |
|
}; |
|
} |
|
else { |
|
// Browser |
|
factory( jQuery, window, document ); |
|
} |
|
}(function( $, window, document, undefined$1 ) { |
|
|
|
// Support libraries which support a Moment like API |
|
var dateLib = window.moment |
|
? window.moment |
|
: window.dayjs |
|
? window.dayjs |
|
: null; |
|
|
|
/* |
|
* This file provides a DateTime GUI picker (calendar and time input). Only the |
|
* format YYYY-MM-DD is supported without additional software, but the end user |
|
* experience can be greatly enhanced by including the momentjs or dayjs library |
|
* which provide date / time parsing and formatting options. |
|
* |
|
* This functionality is required because the HTML5 date and datetime input |
|
* types are not widely supported in desktop browsers. |
|
* |
|
* Constructed by using: |
|
* |
|
* new DateTime( input, opts ) |
|
* |
|
* where `input` is the HTML input element to use and `opts` is an object of |
|
* options based on the `DateTime.defaults` object. |
|
*/ |
|
var DateTime = function ( input, opts ) { |
|
this.c = $.extend( true, {}, DateTime.defaults, opts ); |
|
var classPrefix = this.c.classPrefix; |
|
var i18n = this.c.i18n; |
|
|
|
// Only IS8601 dates are supported without moment pr dayjs |
|
if ( ! dateLib && this.c.format !== 'YYYY-MM-DD' ) { |
|
throw "DateTime: Without momentjs or dayjs only the format 'YYYY-MM-DD' can be used"; |
|
} |
|
|
|
// Min and max need to be `Date` objects in the config |
|
if (typeof this.c.minDate === 'string') { |
|
this.c.minDate = new Date(this.c.minDate); |
|
} |
|
if (typeof this.c.maxDate === 'string') { |
|
this.c.maxDate = new Date(this.c.maxDate); |
|
} |
|
|
|
// DOM structure |
|
var structure = $( |
|
'<div class="'+classPrefix+'">'+ |
|
'<div class="'+classPrefix+'-date">'+ |
|
'<div class="'+classPrefix+'-title">'+ |
|
'<div class="'+classPrefix+'-iconLeft">'+ |
|
'<button>'+i18n.previous+'</button>'+ |
|
'</div>'+ |
|
'<div class="'+classPrefix+'-iconRight">'+ |
|
'<button>'+i18n.next+'</button>'+ |
|
'</div>'+ |
|
'<div class="'+classPrefix+'-label">'+ |
|
'<span></span>'+ |
|
'<select class="'+classPrefix+'-month"></select>'+ |
|
'</div>'+ |
|
'<div class="'+classPrefix+'-label">'+ |
|
'<span></span>'+ |
|
'<select class="'+classPrefix+'-year"></select>'+ |
|
'</div>'+ |
|
'</div>'+ |
|
'<div class="'+classPrefix+'-calendar"></div>'+ |
|
'</div>'+ |
|
'<div class="'+classPrefix+'-time">'+ |
|
'<div class="'+classPrefix+'-hours"></div>'+ |
|
'<div class="'+classPrefix+'-minutes"></div>'+ |
|
'<div class="'+classPrefix+'-seconds"></div>'+ |
|
'</div>'+ |
|
'<div class="'+classPrefix+'-error"></div>'+ |
|
'</div>' |
|
); |
|
|
|
this.dom = { |
|
container: structure, |
|
date: structure.find( '.'+classPrefix+'-date' ), |
|
title: structure.find( '.'+classPrefix+'-title' ), |
|
calendar: structure.find( '.'+classPrefix+'-calendar' ), |
|
time: structure.find( '.'+classPrefix+'-time' ), |
|
error: structure.find( '.'+classPrefix+'-error' ), |
|
input: $(input) |
|
}; |
|
|
|
this.s = { |
|
/** @type {Date} Date value that the picker has currently selected */ |
|
d: null, |
|
|
|
/** @type {Date} Date of the calendar - might not match the value */ |
|
display: null, |
|
|
|
/** @type {number} Used to select minutes in a range where the range base is itself unavailable */ |
|
minutesRange: null, |
|
|
|
/** @type {number} Used to select minutes in a range where the range base is itself unavailable */ |
|
secondsRange: null, |
|
|
|
/** @type {String} Unique namespace string for this instance */ |
|
namespace: 'dateime-'+(DateTime._instance++), |
|
|
|
/** @type {Object} Parts of the picker that should be shown */ |
|
parts: { |
|
date: this.c.format.match( /[YMD]|L(?!T)|l/ ) !== null, |
|
time: this.c.format.match( /[Hhm]|LT|LTS/ ) !== null, |
|
seconds: this.c.format.indexOf( 's' ) !== -1, |
|
hours12: this.c.format.match( /[haA]/ ) !== null |
|
} |
|
}; |
|
|
|
this.dom.container |
|
.append( this.dom.date ) |
|
.append( this.dom.time ) |
|
.append( this.dom.error ); |
|
|
|
this.dom.date |
|
.append( this.dom.title ) |
|
.append( this.dom.calendar ); |
|
|
|
this._constructor(); |
|
}; |
|
|
|
$.extend( DateTime.prototype, { |
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
|
* Public |
|
*/ |
|
|
|
/** |
|
* Destroy the control |
|
*/ |
|
destroy: function () { |
|
this._hide(true); |
|
this.dom.container.off().empty(); |
|
this.dom.input.off('.datetime'); |
|
}, |
|
|
|
errorMsg: function ( msg ) { |
|
var error = this.dom.error; |
|
|
|
if ( msg ) { |
|
error.html( msg ); |
|
} |
|
else { |
|
error.empty(); |
|
} |
|
|
|
return this; |
|
}, |
|
|
|
hide: function () { |
|
this._hide(); |
|
|
|
return this; |
|
}, |
|
|
|
max: function ( date ) { |
|
this.c.maxDate = typeof date === 'string' |
|
? new Date(date) |
|
: date; |
|
|
|
this._optionsTitle(); |
|
this._setCalander(); |
|
|
|
return this; |
|
}, |
|
|
|
min: function ( date ) { |
|
this.c.minDate = typeof date === 'string' |
|
? new Date(date) |
|
: date; |
|
|
|
this._optionsTitle(); |
|
this._setCalander(); |
|
|
|
return this; |
|
}, |
|
|
|
/** |
|
* Check if an element belongs to this control |
|
* |
|
* @param {node} node Element to check |
|
* @return {boolean} true if owned by this control, false otherwise |
|
*/ |
|
owns: function ( node ) { |
|
return $(node).parents().filter( this.dom.container ).length > 0; |
|
}, |
|
|
|
/** |
|
* Get / set the value |
|
* |
|
* @param {string|Date} set Value to set |
|
* @param {boolean} [write=true] Flag to indicate if the formatted value |
|
* should be written into the input element |
|
*/ |
|
val: function ( set, write ) { |
|
if ( set === undefined$1 ) { |
|
return this.s.d; |
|
} |
|
|
|
if ( set instanceof Date ) { |
|
this.s.d = this._dateToUtc( set ); |
|
} |
|
else if ( set === null || set === '' ) { |
|
this.s.d = null; |
|
} |
|
else if ( set === '--now' ) { |
|
this.s.d = new Date(); |
|
} |
|
else if ( typeof set === 'string' ) { |
|
if ( dateLib ) { |
|
// Use moment or dayjs if possible (even for ISO8601 strings, since it |
|
// will correctly handle 0000-00-00 and the like) |
|
var m = dateLib.utc( set, this.c.format, this.c.locale, this.c.strict ); |
|
this.s.d = m.isValid() ? m.toDate() : null; |
|
} |
|
else { |
|
// Else must be using ISO8601 without a date library (constructor would |
|
// have thrown an error otherwise) |
|
var match = set.match(/(\d{4})\-(\d{2})\-(\d{2})/ ); |
|
this.s.d = match ? |
|
new Date( Date.UTC(match[1], match[2]-1, match[3]) ) : |
|
null; |
|
} |
|
} |
|
|
|
if ( write || write === undefined$1 ) { |
|
if ( this.s.d ) { |
|
this._writeOutput(); |
|
} |
|
else { |
|
// The input value was not valid... |
|
this.dom.input.val( set ); |
|
} |
|
} |
|
|
|
// We need a date to be able to display the calendar at all |
|
if ( ! this.s.d ) { |
|
this.s.d = this._dateToUtc( new Date() ); |
|
} |
|
|
|
this.s.display = new Date( this.s.d.toString() ); |
|
|
|
// Set the day of the month to be 1 so changing between months doesn't |
|
// run into issues when going from day 31 to 28 (for example) |
|
this.s.display.setUTCDate( 1 ); |
|
|
|
// Update the display elements for the new value |
|
this._setTitle(); |
|
this._setCalander(); |
|
this._setTime(); |
|
|
|
return this; |
|
}, |
|
|
|
|
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
|
* Constructor |
|
*/ |
|
|
|
/** |
|
* Build the control and assign initial event handlers |
|
* |
|
* @private |
|
*/ |
|
_constructor: function () { |
|
var that = this; |
|
var classPrefix = this.c.classPrefix; |
|
var onChange = function () { |
|
that.c.onChange.call( that, that.dom.input.val(), that.s.d, that.dom.input ); |
|
}; |
|
|
|
if ( ! this.s.parts.date ) { |
|
this.dom.date.css( 'display', 'none' ); |
|
} |
|
|
|
if ( ! this.s.parts.time ) { |
|
this.dom.time.css( 'display', 'none' ); |
|
} |
|
|
|
if ( ! this.s.parts.seconds ) { |
|
this.dom.time.children('div.'+classPrefix+'-seconds').remove(); |
|
this.dom.time.children('span').eq(1).remove(); |
|
} |
|
|
|
// Render the options |
|
this._optionsTitle(); |
|
|
|
window.allan = this; |
|
|
|
// When attached to a hidden input, we always show the input picker, and |
|
// do so inline |
|
if (this.dom.input.attr('type') === 'hidden') { |
|
this.dom.container.addClass('inline'); |
|
this.c.attachTo = 'input'; |
|
|
|
this.val( this.dom.input.val(), false ); |
|
this._show(); |
|
} |
|
|
|
// Trigger the display of the widget when clicking or focusing on the |
|
// input element |
|
this.dom.input |
|
.attr('autocomplete', 'off') |
|
.on('focus.datetime click.datetime', function () { |
|
// If already visible - don't do anything |
|
if ( that.dom.container.is(':visible') || that.dom.input.is(':disabled') ) { |
|
return; |
|
} |
|
|
|
// In case the value has changed by text |
|
that.val( that.dom.input.val(), false ); |
|
|
|
that._show(); |
|
} ) |
|
.on('keyup.datetime', function () { |
|
// Update the calendar's displayed value as the user types |
|
if ( that.dom.container.is(':visible') ) { |
|
that.val( that.dom.input.val(), false ); |
|
} |
|
} ); |
|
|
|
// Main event handlers for input in the widget |
|
this.dom.container |
|
.on( 'change', 'select', function () { |
|
var select = $(this); |
|
var val = select.val(); |
|
|
|
if ( select.hasClass(classPrefix+'-month') ) { |
|
// Month select |
|
that._correctMonth( that.s.display, val ); |
|
that._setTitle(); |
|
that._setCalander(); |
|
} |
|
else if ( select.hasClass(classPrefix+'-year') ) { |
|
// Year select |
|
that.s.display.setUTCFullYear( val ); |
|
that._setTitle(); |
|
that._setCalander(); |
|
} |
|
else if ( select.hasClass(classPrefix+'-hours') || select.hasClass(classPrefix+'-ampm') ) { |
|
// Hours - need to take account of AM/PM input if present |
|
if ( that.s.parts.hours12 ) { |
|
var hours = $(that.dom.container).find('.'+classPrefix+'-hours').val() * 1; |
|
var pm = $(that.dom.container).find('.'+classPrefix+'-ampm').val() === 'pm'; |
|
|
|
that.s.d.setUTCHours( hours === 12 && !pm ? |
|
0 : |
|
pm && hours !== 12 ? |
|
hours + 12 : |
|
hours |
|
); |
|
} |
|
else { |
|
that.s.d.setUTCHours( val ); |
|
} |
|
|
|
that._setTime(); |
|
that._writeOutput( true ); |
|
|
|
onChange(); |
|
} |
|
else if ( select.hasClass(classPrefix+'-minutes') ) { |
|
// Minutes select |
|
that.s.d.setUTCMinutes( val ); |
|
that._setTime(); |
|
that._writeOutput( true ); |
|
|
|
onChange(); |
|
} |
|
else if ( select.hasClass(classPrefix+'-seconds') ) { |
|
// Seconds select |
|
that.s.d.setSeconds( val ); |
|
that._setTime(); |
|
that._writeOutput( true ); |
|
|
|
onChange(); |
|
} |
|
|
|
that.dom.input.focus(); |
|
that._position(); |
|
} ) |
|
.on( 'click', function (e) { |
|
var d = that.s.d; |
|
var nodeName = e.target.nodeName.toLowerCase(); |
|
var target = nodeName === 'span' ? |
|
e.target.parentNode : |
|
e.target; |
|
|
|
nodeName = target.nodeName.toLowerCase(); |
|
|
|
if ( nodeName === 'select' ) { |
|
return; |
|
} |
|
|
|
e.stopPropagation(); |
|
|
|
if ( nodeName === 'button' ) { |
|
var button = $(target); |
|
var parent = button.parent(); |
|
|
|
if ( parent.hasClass('disabled') && ! parent.hasClass('range') ) { |
|
button.blur(); |
|
return; |
|
} |
|
|
|
if ( parent.hasClass(classPrefix+'-iconLeft') ) { |
|
// Previous month |
|
that.s.display.setUTCMonth( that.s.display.getUTCMonth()-1 ); |
|
that._setTitle(); |
|
that._setCalander(); |
|
|
|
that.dom.input.focus(); |
|
} |
|
else if ( parent.hasClass(classPrefix+'-iconRight') ) { |
|
// Next month |
|
that._correctMonth( that.s.display, that.s.display.getUTCMonth()+1 ); |
|
that._setTitle(); |
|
that._setCalander(); |
|
|
|
that.dom.input.focus(); |
|
} |
|
else if ( button.parents('.'+classPrefix+'-time').length ) { |
|
var val = button.data('value'); |
|
var unit = button.data('unit'); |
|
|
|
if ( unit === 'minutes' ) { |
|
if ( parent.hasClass('disabled') && parent.hasClass('range') ) { |
|
that.s.minutesRange = val; |
|
that._setTime(); |
|
return; |
|
} |
|
else { |
|
that.s.minutesRange = null; |
|
} |
|
} |
|
|
|
if ( unit === 'seconds' ) { |
|
if ( parent.hasClass('disabled') && parent.hasClass('range') ) { |
|
that.s.secondsRange = val; |
|
that._setTime(); |
|
return; |
|
} |
|
else { |
|
that.s.secondsRange = null; |
|
} |
|
} |
|
|
|
// Specific to hours for 12h clock |
|
if ( val === 'am' ) { |
|
if ( d.getUTCHours() >= 12 ) { |
|
val = d.getUTCHours() - 12; |
|
} |
|
else { |
|
return; |
|
} |
|
} |
|
else if ( val === 'pm' ) { |
|
if ( d.getUTCHours() < 12 ) { |
|
val = d.getUTCHours() + 12; |
|
} |
|
else { |
|
return; |
|
} |
|
} |
|
|
|
var set = unit === 'hours' ? |
|
'setUTCHours' : |
|
unit === 'minutes' ? |
|
'setUTCMinutes' : |
|
'setSeconds'; |
|
|
|
d[set]( val ); |
|
that._setTime(); |
|
that._writeOutput( true ); |
|
onChange(); |
|
} |
|
else { |
|
// Calendar click |
|
if ( ! d ) { |
|
d = that._dateToUtc( new Date() ); |
|
} |
|
|
|
// Can't be certain that the current day will exist in |
|
// the new month, and likewise don't know that the |
|
// new day will exist in the old month, But 1 always |
|
// does, so we can change the month without worry of a |
|
// recalculation being done automatically by `Date` |
|
d.setUTCDate( 1 ); |
|
d.setUTCFullYear( button.data('year') ); |
|
d.setUTCMonth( button.data('month') ); |
|
d.setUTCDate( button.data('day') ); |
|
|
|
that._writeOutput( true ); |
|
|
|
// Don't hide if there is a time picker, since we want to |
|
// be able to select a time as well. |
|
if ( ! that.s.parts.time ) { |
|
// This is annoying but IE has some kind of async |
|
// behaviour with focus and the focus from the above |
|
// write would occur after this hide - resulting in the |
|
// calendar opening immediately |
|
setTimeout( function () { |
|
that._hide(); |
|
}, 10 ); |
|
} |
|
else { |
|
that._setCalander(); |
|
} |
|
|
|
onChange(); |
|
} |
|
} |
|
else { |
|
// Click anywhere else in the widget - return focus to the |
|
// input element |
|
that.dom.input.focus(); |
|
} |
|
} ); |
|
}, |
|
|
|
|
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
|
* Private |
|
*/ |
|
|
|
/** |
|
* Compare the date part only of two dates - this is made super easy by the |
|
* toDateString method! |
|
* |
|
* @param {Date} a Date 1 |
|
* @param {Date} b Date 2 |
|
* @private |
|
*/ |
|
_compareDates: function( a, b ) { |
|
// Can't use toDateString as that converts to local time |
|
return this._dateToUtcString(a) === this._dateToUtcString(b); |
|
}, |
|
|
|
/** |
|
* When changing month, take account of the fact that some months don't have |
|
* the same number of days. For example going from January to February you |
|
* can have the 31st of Jan selected and just add a month since the date |
|
* would still be 31, and thus drop you into March. |
|
* |
|
* @param {Date} date Date - will be modified |
|
* @param {integer} month Month to set |
|
* @private |
|
*/ |
|
_correctMonth: function ( date, month ) { |
|
var days = this._daysInMonth( date.getUTCFullYear(), month ); |
|
var correctDays = date.getUTCDate() > days; |
|
|
|
date.setUTCMonth( month ); |
|
|
|
if ( correctDays ) { |
|
date.setUTCDate( days ); |
|
date.setUTCMonth( month ); |
|
} |
|
}, |
|
|
|
/** |
|
* Get the number of days in a method. Based on |
|
* http://stackoverflow.com/a/4881951 by Matti Virkkunen |
|
* |
|
* @param {integer} year Year |
|
* @param {integer} month Month (starting at 0) |
|
* @private |
|
*/ |
|
_daysInMonth: function ( year, month ) { |
|
// |
|
var isLeap = ((year % 4) === 0 && ((year % 100) !== 0 || (year % 400) === 0)); |
|
var months = [31, (isLeap ? 29 : 28), 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; |
|
|
|
return months[month]; |
|
}, |
|
|
|
/** |
|
* Create a new date object which has the UTC values set to the local time. |
|
* This allows the local time to be used directly for the library which |
|
* always bases its calculations and display on UTC. |
|
* |
|
* @param {Date} s Date to "convert" |
|
* @return {Date} Shifted date |
|
*/ |
|
_dateToUtc: function ( s ) { |
|
return new Date( Date.UTC( |
|
s.getFullYear(), s.getMonth(), s.getDate(), |
|
s.getHours(), s.getMinutes(), s.getSeconds() |
|
) ); |
|
}, |
|
|
|
/** |
|
* Create a UTC ISO8601 date part from a date object |
|
* |
|
* @param {Date} d Date to "convert" |
|
* @return {string} ISO formatted date |
|
*/ |
|
_dateToUtcString: function ( d ) { |
|
return d.getUTCFullYear()+'-'+ |
|
this._pad(d.getUTCMonth()+1)+'-'+ |
|
this._pad(d.getUTCDate()); |
|
}, |
|
|
|
/** |
|
* Hide the control and remove events related to its display |
|
* |
|
* @private |
|
*/ |
|
_hide: function (destroy) { |
|
if (! destroy && this.dom.input.attr('type') === 'hidden') { |
|
return; |
|
} |
|
|
|
var namespace = this.s.namespace; |
|
|
|
this.dom.container.detach(); |
|
|
|
$(window).off( '.'+namespace ); |
|
$(document).off( 'keydown.'+namespace ); |
|
$('div.dataTables_scrollBody').off( 'scroll.'+namespace ); |
|
$('div.DTE_Body_Content').off( 'scroll.'+namespace ); |
|
$('body').off( 'click.'+namespace ); |
|
}, |
|
|
|
/** |
|
* Convert a 24 hour value to a 12 hour value |
|
* |
|
* @param {integer} val 24 hour value |
|
* @return {integer} 12 hour value |
|
* @private |
|
*/ |
|
_hours24To12: function ( val ) { |
|
return val === 0 ? |
|
12 : |
|
val > 12 ? |
|
val - 12 : |
|
val; |
|
}, |
|
|
|
/** |
|
* Generate the HTML for a single day in the calendar - this is basically |
|
* and HTML cell with a button that has data attributes so we know what was |
|
* clicked on (if it is clicked on) and a bunch of classes for styling. |
|
* |
|
* @param {object} day Day object from the `_htmlMonth` method |
|
* @return {string} HTML cell |
|
*/ |
|
_htmlDay: function( day ) |
|
{ |
|
if ( day.empty ) { |
|
return '<td class="empty"></td>'; |
|
} |
|
|
|
var classes = [ 'selectable' ]; |
|
var classPrefix = this.c.classPrefix; |
|
|
|
if ( day.disabled ) { |
|
classes.push( 'disabled' ); |
|
} |
|
|
|
if ( day.today ) { |
|
classes.push( 'now' ); |
|
} |
|
|
|
if ( day.selected ) { |
|
classes.push( 'selected' ); |
|
} |
|
|
|
return '<td data-day="' + day.day + '" class="' + classes.join(' ') + '">' + |
|
'<button class="'+classPrefix+'-button '+classPrefix+'-day" type="button" ' +'data-year="' + day.year + '" data-month="' + day.month + '" data-day="' + day.day + '">' + |
|
'<span>'+day.day+'</span>'+ |
|
'</button>' + |
|
'</td>'; |
|
}, |
|
|
|
|
|
/** |
|
* Create the HTML for a month to be displayed in the calendar table. |
|
* |
|
* Based upon the logic used in Pikaday - MIT licensed |
|
* Copyright (c) 2014 David Bushell |
|
* https://github.com/dbushell/Pikaday |
|
* |
|
* @param {integer} year Year |
|
* @param {integer} month Month (starting at 0) |
|
* @return {string} Calendar month HTML |
|
* @private |
|
*/ |
|
_htmlMonth: function ( year, month ) { |
|
var now = this._dateToUtc( new Date() ), |
|
days = this._daysInMonth( year, month ), |
|
before = new Date( Date.UTC(year, month, 1) ).getUTCDay(), |
|
data = [], |
|
row = []; |
|
|
|
if ( this.c.firstDay > 0 ) { |
|
before -= this.c.firstDay; |
|
|
|
if (before < 0) { |
|
before += 7; |
|
} |
|
} |
|
|
|
var cells = days + before, |
|
after = cells; |
|
|
|
while ( after > 7 ) { |
|
after -= 7; |
|
} |
|
|
|
cells += 7 - after; |
|
|
|
var minDate = this.c.minDate; |
|
var maxDate = this.c.maxDate; |
|
|
|
if ( minDate ) { |
|
minDate.setUTCHours(0); |
|
minDate.setUTCMinutes(0); |
|
minDate.setSeconds(0); |
|
} |
|
|
|
if ( maxDate ) { |
|
maxDate.setUTCHours(23); |
|
maxDate.setUTCMinutes(59); |
|
maxDate.setSeconds(59); |
|
} |
|
|
|
for ( var i=0, r=0 ; i<cells ; i++ ) { |
|
var day = new Date( Date.UTC(year, month, 1 + (i - before)) ), |
|
selected = this.s.d ? this._compareDates(day, this.s.d) : false, |
|
today = this._compareDates(day, now), |
|
empty = i < before || i >= (days + before), |
|
disabled = (minDate && day < minDate) || |
|
(maxDate && day > maxDate); |
|
|
|
var disableDays = this.c.disableDays; |
|
if ( Array.isArray( disableDays ) && $.inArray( day.getUTCDay(), disableDays ) !== -1 ) { |
|
disabled = true; |
|
} |
|
else if ( typeof disableDays === 'function' && disableDays( day ) === true ) { |
|
disabled = true; |
|
} |
|
|
|
var dayConfig = { |
|
day: 1 + (i - before), |
|
month: month, |
|
year: year, |
|
selected: selected, |
|
today: today, |
|
disabled: disabled, |
|
empty: empty |
|
}; |
|
|
|
row.push( this._htmlDay(dayConfig) ); |
|
|
|
if ( ++r === 7 ) { |
|
if ( this.c.showWeekNumber ) { |
|
row.unshift( this._htmlWeekOfYear(i - before, month, year) ); |
|
} |
|
|
|
data.push( '<tr>'+row.join('')+'</tr>' ); |
|
row = []; |
|
r = 0; |
|
} |
|
} |
|
|
|
var classPrefix = this.c.classPrefix; |
|
var className = classPrefix+'-table'; |
|
if ( this.c.showWeekNumber ) { |
|
className += ' weekNumber'; |
|
} |
|
|
|
// Show / hide month icons based on min/max |
|
if ( minDate ) { |
|
var underMin = minDate >= new Date( Date.UTC(year, month, 1, 0, 0, 0 ) ); |
|
|
|
this.dom.title.find('div.'+classPrefix+'-iconLeft') |
|
.css( 'display', underMin ? 'none' : 'block' ); |
|
} |
|
|
|
if ( maxDate ) { |
|
var overMax = maxDate < new Date( Date.UTC(year, month+1, 1, 0, 0, 0 ) ); |
|
|
|
this.dom.title.find('div.'+classPrefix+'-iconRight') |
|
.css( 'display', overMax ? 'none' : 'block' ); |
|
} |
|
|
|
return '<table class="'+className+'">' + |
|
'<thead>'+ |
|
this._htmlMonthHead() + |
|
'</thead>'+ |
|
'<tbody>'+ |
|
data.join('') + |
|
'</tbody>'+ |
|
'</table>'; |
|
}, |
|
|
|
/** |
|
* Create the calendar table's header (week days) |
|
* |
|
* @return {string} HTML cells for the row |
|
* @private |
|
*/ |
|
_htmlMonthHead: function () { |
|
var a = []; |
|
var firstDay = this.c.firstDay; |
|
var i18n = this.c.i18n; |
|
|
|
// Take account of the first day shift |
|
var dayName = function ( day ) { |
|
day += firstDay; |
|
|
|
while (day >= 7) { |
|
day -= 7; |
|
} |
|
|
|
return i18n.weekdays[day]; |
|
}; |
|
|
|
// Empty cell in the header |
|
if ( this.c.showWeekNumber ) { |
|
a.push( '<th></th>' ); |
|
} |
|
|
|
for ( var i=0 ; i<7 ; i++ ) { |
|
a.push( '<th>'+dayName( i )+'</th>' ); |
|
} |
|
|
|
return a.join(''); |
|
}, |
|
|
|
/** |
|
* Create a cell that contains week of the year - ISO8601 |
|
* |
|
* Based on https://stackoverflow.com/questions/6117814/ and |
|
* http://techblog.procurios.nl/k/n618/news/view/33796/14863/ |
|
* |
|
* @param {integer} d Day of month |
|
* @param {integer} m Month of year (zero index) |
|
* @param {integer} y Year |
|
* @return {string} |
|
* @private |
|
*/ |
|
_htmlWeekOfYear: function ( d, m, y ) { |
|
var date = new Date( y, m, d, 0, 0, 0, 0 ); |
|
|
|
// First week of the year always has 4th January in it |
|
date.setDate( date.getDate() + 4 - (date.getDay() || 7) ); |
|
|
|
var oneJan = new Date( y, 0, 1 ); |
|
var weekNum = Math.ceil( ( ( (date - oneJan) / 86400000) + 1)/7 ); |
|
|
|
return '<td class="'+this.c.classPrefix+'-week">' + weekNum + '</td>'; |
|
}, |
|
|
|
/** |
|
* Create option elements from a range in an array |
|
* |
|
* @param {string} selector Class name unique to the select element to use |
|
* @param {array} values Array of values |
|
* @param {array} [labels] Array of labels. If given must be the same |
|
* length as the values parameter. |
|
* @private |
|
*/ |
|
_options: function ( selector, values, labels ) { |
|
if ( ! labels ) { |
|
labels = values; |
|
} |
|
|
|
var select = this.dom.container.find('select.'+this.c.classPrefix+'-'+selector); |
|
select.empty(); |
|
|
|
for ( var i=0, ien=values.length ; i<ien ; i++ ) { |
|
select.append( '<option value="'+values[i]+'">'+labels[i]+'</option>' ); |
|
} |
|
}, |
|
|
|
/** |
|
* Set an option and update the option's span pair (since the select element |
|
* has opacity 0 for styling) |
|
* |
|
* @param {string} selector Class name unique to the select element to use |
|
* @param {*} val Value to set |
|
* @private |
|
*/ |
|
_optionSet: function ( selector, val ) { |
|
var select = this.dom.container.find('select.'+this.c.classPrefix+'-'+selector); |
|
var span = select.parent().children('span'); |
|
|
|
select.val( val ); |
|
|
|
var selected = select.find('option:selected'); |
|
span.html( selected.length !== 0 ? |
|
selected.text() : |
|
this.c.i18n.unknown |
|
); |
|
}, |
|
|
|
/** |
|
* Create time options list. |
|
* |
|
* @param {string} unit Time unit - hours, minutes or seconds |
|
* @param {integer} count Count range - 12, 24 or 60 |
|
* @param {integer} val Existing value for this unit |
|
* @param {integer[]} allowed Values allow for selection |
|
* @param {integer} range Override range |
|
* @private |
|
*/ |
|
_optionsTime: function ( unit, count, val, allowed, range ) { |
|
var classPrefix = this.c.classPrefix; |
|
var container = this.dom.container.find('div.'+classPrefix+'-'+unit); |
|
var i, j; |
|
var render = count === 12 ? |
|
function (i) { return i; } : |
|
this._pad; |
|
var classPrefix = this.c.classPrefix; |
|
var className = classPrefix+'-table'; |
|
var i18n = this.c.i18n; |
|
|
|
if ( ! container.length ) { |
|
return; |
|
} |
|
|
|
var a = ''; |
|
var span = 10; |
|
var button = function (value, label, className) { |
|
// Shift the value for PM |
|
if ( count === 12 && typeof value === 'number' ) { |
|
if (val >= 12 ) { |
|
value += 12; |
|
} |
|
|
|
if (value == 12) { |
|
value = 0; |
|
} |
|
else if (value == 24) { |
|
value = 12; |
|
} |
|
} |
|
|
|
var selected = val === value || (value === 'am' && val < 12) || (value === 'pm' && val >= 12) ? |
|
'selected' : |
|
''; |
|
|
|
if (allowed && $.inArray(value, allowed) === -1) { |
|
selected += ' disabled'; |
|
} |
|
|
|
if ( className ) { |
|
selected += ' '+className; |
|
} |
|
|
|
return '<td class="selectable '+selected+'">' + |
|
'<button class="'+classPrefix+'-button '+classPrefix+'-day" type="button" data-unit="'+unit+'" data-value="'+value+ '">' + |
|
'<span>'+label+'</span>'+ |
|
'</button>' + |
|
'</td>'; |
|
}; |
|
|
|
if ( count === 12 ) { |
|
// Hours with AM/PM |
|
a += '<tr>'; |
|
|
|
for ( i=1 ; i<=6 ; i++ ) { |
|
a += button(i, render(i)); |
|
} |
|
a += button('am', i18n.amPm[0]); |
|
|
|
a += '</tr>'; |
|
a += '<tr>'; |
|
|
|
for ( i=7 ; i<=12 ; i++ ) { |
|
a += button(i, render(i)); |
|
} |
|
a += button('pm', i18n.amPm[1]); |
|
a += '</tr>'; |
|
|
|
span = 7; |
|
} |
|
else if ( count === 24 ) { |
|
// Hours - 24 |
|
var c = 0; |
|
for (j=0 ; j<4 ; j++ ) { |
|
a += '<tr>'; |
|
for ( i=0 ; i<6 ; i++ ) { |
|
a += button(c, render(c)); |
|
c++; |
|
} |
|
a += '</tr>'; |
|
} |
|
|
|
span = 6; |
|
} |
|
else { |
|
// Minutes and seconds |
|
a += '<tr>'; |
|
for (j=0 ; j<60 ; j+=10 ) { |
|
a += button(j, render(j), 'range'); |
|
} |
|
a += '</tr>'; |
|
|
|
// Slight hack to allow for the different number of columns |
|
a += '</tbody></thead><table class="'+className+' '+className+'-nospace"><tbody>'; |
|
|
|
var start = range !== null ? |
|
range : |
|
Math.floor( val / 10 )*10; |
|
|
|
a += '<tr>'; |
|
for (j=start+1 ; j<start+10 ; j++ ) { |
|
a += button(j, render(j)); |
|
} |
|
a += '</tr>'; |
|
|
|
span = 6; |
|
} |
|
|
|
container |
|
.empty() |
|
.append( |
|
'<table class="'+className+'">'+ |
|
'<thead><tr><th colspan="'+span+'">'+ |
|
i18n[unit] + |
|
'</th></tr></thead>'+ |
|
'<tbody>'+ |
|
a+ |
|
'</tbody>'+ |
|
'</table>' |
|
); |
|
}, |
|
|
|
/** |
|
* Create the options for the month and year |
|
* |
|
* @param {integer} year Year |
|
* @param {integer} month Month (starting at 0) |
|
* @private |
|
*/ |
|
_optionsTitle: function () { |
|
var i18n = this.c.i18n; |
|
var min = this.c.minDate; |
|
var max = this.c.maxDate; |
|
var minYear = min ? min.getFullYear() : null; |
|
var maxYear = max ? max.getFullYear() : null; |
|
|
|
var i = minYear !== null ? minYear : new Date().getFullYear() - this.c.yearRange; |
|
var j = maxYear !== null ? maxYear : new Date().getFullYear() + this.c.yearRange; |
|
|
|
this._options( 'month', this._range( 0, 11 ), i18n.months ); |
|
this._options( 'year', this._range( i, j ) ); |
|
}, |
|
|
|
/** |
|
* Simple two digit pad |
|
* |
|
* @param {integer} i Value that might need padding |
|
* @return {string|integer} Padded value |
|
* @private |
|
*/ |
|
_pad: function ( i ) { |
|
return i<10 ? '0'+i : i; |
|
}, |
|
|
|
/** |
|
* Position the calendar to look attached to the input element |
|
* @private |
|
*/ |
|
_position: function () { |
|
var offset = this.c.attachTo === 'input' ? this.dom.input.position() : this.dom.input.offset(); |
|
var container = this.dom.container; |
|
var inputHeight = this.dom.input.outerHeight(); |
|
|
|
if (container.hasClass('inline')) { |
|
container.insertAfter( this.dom.input ); |
|
return; |
|
} |
|
|
|
if ( this.s.parts.date && this.s.parts.time && $(window).width() > 550 ) { |
|
container.addClass('horizontal'); |
|
} |
|
else { |
|
container.removeClass('horizontal'); |
|
} |
|
|
|
if(this.c.attachTo === 'input') { |
|
container |
|
.css( { |
|
top: offset.top + inputHeight, |
|
left: offset.left |
|
} ) |
|
.insertAfter( this.dom.input ); |
|
} |
|
else { |
|
container |
|
.css( { |
|
top: offset.top + inputHeight, |
|
left: offset.left |
|
} ) |
|
.appendTo( 'body' ); |
|
} |
|
|
|
var calHeight = container.outerHeight(); |
|
var calWidth = container.outerWidth(); |
|
var scrollTop = $(window).scrollTop(); |
|
|
|
// Correct to the bottom |
|
if ( offset.top + inputHeight + calHeight - scrollTop > $(window).height() ) { |
|
var newTop = offset.top - calHeight; |
|
|
|
container.css( 'top', newTop < 0 ? 0 : newTop ); |
|
} |
|
|
|
// Correct to the right |
|
if ( calWidth + offset.left > $(window).width() ) { |
|
var newLeft = $(window).width() - calWidth; |
|
|
|
// Account for elements which are inside a position absolute element |
|
if (this.c.attachTo === 'input') { |
|
newLeft -= $(container).offsetParent().offset().left; |
|
} |
|
|
|
container.css( 'left', newLeft < 0 ? 0 : newLeft ); |
|
} |
|
}, |
|
|
|
/** |
|
* Create a simple array with a range of values |
|
* |
|
* @param {integer} start Start value (inclusive) |
|
* @param {integer} end End value (inclusive) |
|
* @param {integer} [inc=1] Increment value |
|
* @return {array} Created array |
|
* @private |
|
*/ |
|
_range: function ( start, end, inc ) { |
|
var a = []; |
|
|
|
if ( ! inc ) { |
|
inc = 1; |
|
} |
|
|
|
for ( var i=start ; i<=end ; i+=inc ) { |
|
a.push( i ); |
|
} |
|
|
|
return a; |
|
}, |
|
|
|
/** |
|
* Redraw the calendar based on the display date - this is a destructive |
|
* operation |
|
* |
|
* @private |
|
*/ |
|
_setCalander: function () { |
|
if ( this.s.display ) { |
|
this.dom.calendar |
|
.empty() |
|
.append( this._htmlMonth( |
|
this.s.display.getUTCFullYear(), |
|
this.s.display.getUTCMonth() |
|
) ); |
|
} |
|
}, |
|
|
|
/** |
|
* Set the month and year for the calendar based on the current display date |
|
* |
|
* @private |
|
*/ |
|
_setTitle: function () { |
|
this._optionSet( 'month', this.s.display.getUTCMonth() ); |
|
this._optionSet( 'year', this.s.display.getUTCFullYear() ); |
|
}, |
|
|
|
/** |
|
* Set the time based on the current value of the widget |
|
* |
|
* @private |
|
*/ |
|
_setTime: function () { |
|
var that = this; |
|
var d = this.s.d; |
|
var hours = d ? d.getUTCHours() : 0; |
|
var allowed = function ( prop ) { // Backwards compt with `Increment` option |
|
return that.c[prop+'Available'] ? |
|
that.c[prop+'Available'] : |
|
that._range( 0, 59, that.c[prop+'Increment'] ); |
|
}; |
|
|
|
this._optionsTime( 'hours', this.s.parts.hours12 ? 12 : 24, hours, this.c.hoursAvailable ); |
|
this._optionsTime( 'minutes', 60, d ? d.getUTCMinutes() : 0, allowed('minutes'), this.s.minutesRange ); |
|
this._optionsTime( 'seconds', 60, d ? d.getSeconds() : 0, allowed('seconds'), this.s.secondsRange ); |
|
}, |
|
|
|
/** |
|
* Show the widget and add events to the document required only while it |
|
* is displayed |
|
* |
|
* @private |
|
*/ |
|
_show: function () { |
|
var that = this; |
|
var namespace = this.s.namespace; |
|
|
|
this._position(); |
|
|
|
// Need to reposition on scroll |
|
$(window).on( 'scroll.'+namespace+' resize.'+namespace, function () { |
|
that._hide(); |
|
} ); |
|
|
|
$('div.DTE_Body_Content').on( 'scroll.'+namespace, function () { |
|
that._hide(); |
|
} ); |
|
|
|
$('div.dataTables_scrollBody').on( 'scroll.'+namespace, function () { |
|
that._hide(); |
|
} ); |
|
|
|
var offsetParent = this.dom.input[0].offsetParent; |
|
|
|
if ( offsetParent !== document.body ) { |
|
$(offsetParent).on( 'scroll.'+namespace, function () { |
|
that._hide(); |
|
} ); |
|
} |
|
|
|
// On tab focus will move to a different field (no keyboard navigation |
|
// in the date picker - this might need to be changed). |
|
$(document).on( 'keydown.'+namespace, function (e) { |
|
if ( |
|
e.keyCode === 9 || // tab |
|
e.keyCode === 27 || // esc |
|
e.keyCode === 13 // return |
|
) { |
|
that._hide(); |
|
} |
|
} ); |
|
|
|
// Hide if clicking outside of the widget - but in a different click |
|
// event from the one that was used to trigger the show (bubble and |
|
// inline) |
|
setTimeout( function () { |
|
$('body').on( 'click.'+namespace, function (e) { |
|
var parents = $(e.target).parents(); |
|
|
|
if ( ! parents.filter( that.dom.container ).length && e.target !== that.dom.input[0] ) { |
|
that._hide(); |
|
} |
|
} ); |
|
}, 10 ); |
|
}, |
|
|
|
/** |
|
* Write the formatted string to the input element this control is attached |
|
* to |
|
* |
|
* @private |
|
*/ |
|
_writeOutput: function ( focus ) { |
|
var date = this.s.d; |
|
|
|
// Use moment or dayjs if possible - otherwise it must be ISO8601 (or the |
|
// constructor would have thrown an error) |
|
var out = dateLib ? |
|
dateLib.utc( date, undefined$1, this.c.locale, this.c.strict ).format( this.c.format ) : |
|
date.getUTCFullYear() +'-'+ |
|
this._pad(date.getUTCMonth() + 1) +'-'+ |
|
this._pad(date.getUTCDate()); |
|
|
|
this.dom.input |
|
.val( out ) |
|
.trigger('change', {write: date}); |
|
|
|
if ( this.dom.input.attr('type') === 'hidden' ) { |
|
this.val(out, false); |
|
} |
|
|
|
if ( focus ) { |
|
this.dom.input.focus(); |
|
} |
|
} |
|
} ); |
|
|
|
/** |
|
* Use a specificmoment compatible date library |
|
*/ |
|
DateTime.use = function (lib) { |
|
dateLib = lib; |
|
}; |
|
|
|
/** |
|
* For generating unique namespaces |
|
* |
|
* @type {Number} |
|
* @private |
|
*/ |
|
DateTime._instance = 0; |
|
|
|
/** |
|
* Defaults for the date time picker |
|
* |
|
* @type {Object} |
|
*/ |
|
DateTime.defaults = { |
|
attachTo: 'body', |
|
|
|
// Not documented - could be an internal property |
|
classPrefix: 'dt-datetime', |
|
|
|
// function or array of ints |
|
disableDays: null, |
|
|
|
// first day of the week (0: Sunday, 1: Monday, etc) |
|
firstDay: 1, |
|
|
|
format: 'YYYY-MM-DD', |
|
|
|
hoursAvailable: null, |
|
|
|
i18n: { |
|
previous: 'Previous', |
|
next: 'Next', |
|
months: [ 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December' ], |
|
weekdays: [ 'Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat' ], |
|
amPm: [ 'am', 'pm' ], |
|
hours: 'Hour', |
|
minutes: 'Minute', |
|
seconds: 'Second', |
|
unknown: '-' |
|
}, |
|
|
|
maxDate: null, |
|
|
|
minDate: null, |
|
|
|
minutesAvailable: null, |
|
|
|
minutesIncrement: 1, // deprecated |
|
|
|
strict: true, |
|
|
|
locale: 'en', |
|
|
|
onChange: function () {}, |
|
|
|
secondsAvailable: null, |
|
|
|
secondsIncrement: 1, // deprecated |
|
|
|
// show the ISO week number at the head of the row |
|
showWeekNumber: false, |
|
|
|
// overruled by max / min date |
|
yearRange: 25 |
|
}; |
|
|
|
DateTime.version = '1.0.1'; |
|
|
|
// Global export - if no conflicts |
|
if (! window.DateTime) { |
|
window.DateTime = DateTime; |
|
} |
|
|
|
// Make available via jQuery |
|
$.fn.dtDateTime = function (options) { |
|
return this.each(function() { |
|
new DateTime(this, options); |
|
}); |
|
}; |
|
|
|
// Attach to DataTables if present |
|
if ($.fn.dataTable) { |
|
$.fn.dataTable.DateTime = DateTime; |
|
$.fn.DataTable.DateTime = DateTime; |
|
} |
|
|
|
return DateTime; |
|
|
|
})); |
|
|
|
var $; |
|
var DataTable; |
|
var moment = window.moment; |
|
/** |
|
* Sets the value of jQuery for use in the file |
|
* @param jq the instance of jQuery to be set |
|
*/ |
|
function setJQuery(jq) { |
|
$ = jq; |
|
DataTable = jq.fn.dataTable; |
|
} |
|
/** |
|
* The Criteria class is used within SearchBuilder to represent a search criteria |
|
*/ |
|
var Criteria = /** @class */ (function () { |
|
function Criteria(table, opts, topGroup, index, depth) { |
|
var _this = this; |
|
if (index === void 0) { index = 0; } |
|
if (depth === void 0) { depth = 1; } |
|
// Check that the required version of DataTables is included |
|
if (!DataTable || !DataTable.versionCheck || !DataTable.versionCheck('1.10.0')) { |
|
throw new Error('SearchPane requires DataTables 1.10 or newer'); |
|
} |
|
this.classes = $.extend(true, {}, Criteria.classes); |
|
// Get options from user and any extra conditions/column types defined by plug-ins |
|
this.c = $.extend(true, {}, Criteria.defaults, $.fn.dataTable.ext.searchBuilder, opts); |
|
var i18n = this.c.i18n; |
|
this.s = { |
|
condition: undefined, |
|
conditions: {}, |
|
data: undefined, |
|
dataIdx: -1, |
|
dataPoints: [], |
|
depth: depth, |
|
dt: table, |
|
filled: false, |
|
index: index, |
|
momentFormat: false, |
|
topGroup: topGroup, |
|
type: '', |
|
value: [] |
|
}; |
|
this.dom = { |
|
buttons: $('<div/>') |
|
.addClass(this.classes.buttonContainer), |
|
condition: $('<select disabled/>') |
|
.addClass(this.classes.condition) |
|
.addClass(this.classes.dropDown) |
|
.addClass(this.classes.italic) |
|
.attr('autocomplete', 'hacking'), |
|
conditionTitle: $('<option value="" disabled selected hidden/>') |
|
.text(this.s.dt.i18n('searchBuilder.condition', i18n.condition)), |
|
container: $('<div/>') |
|
.addClass(this.classes.container), |
|
data: $('<select/>') |
|
.addClass(this.classes.data) |
|
.addClass(this.classes.dropDown) |
|
.addClass(this.classes.italic), |
|
dataTitle: $('<option value="" disabled selected hidden/>') |
|
.text(this.s.dt.i18n('searchBuilder.data', i18n.data)), |
|
defaultValue: $('<select disabled/>') |
|
.addClass(this.classes.value) |
|
.addClass(this.classes.dropDown), |
|
"delete": $('<button>×</button>') |
|
.addClass(this.classes["delete"]) |
|
.addClass(this.classes.button) |
|
.attr('title', this.s.dt.i18n('searchBuilder.deleteTitle', i18n.deleteTitle)) |
|
.attr('type', 'button'), |
|
left: $('<button>\<</button>') |
|
.addClass(this.classes.left) |
|
.addClass(this.classes.button) |
|
.attr('title', this.s.dt.i18n('searchBuilder.leftTitle', i18n.leftTitle)) |
|
.attr('type', 'button'), |
|
right: $('<button>\></button>') |
|
.addClass(this.classes.right) |
|
.addClass(this.classes.button) |
|
.attr('title', this.s.dt.i18n('searchBuilder.rightTitle', i18n.rightTitle)) |
|
.attr('type', 'button'), |
|
value: [ |
|
$('<select disabled/>').addClass(this.classes.value).addClass(this.classes.dropDown).addClass(this.classes.italic) |
|
], |
|
valueTitle: $('<option value="--valueTitle--" selected/>').text(this.s.dt.i18n('searchBuilder.value', i18n.value)) |
|
}; |
|
// If the greyscale option is selected then add the class to add the grey colour to SearchBuilder |
|
if (this.c.greyscale) { |
|
$(this.dom.data).addClass(this.classes.greyscale); |
|
$(this.dom.condition).addClass(this.classes.greyscale); |
|
$(this.dom.defaultValue).addClass(this.classes.greyscale); |
|
for (var _i = 0, _a = this.dom.value; _i < _a.length; _i++) { |
|
var val = _a[_i]; |
|
$(val).addClass(this.classes.greyscale); |
|
} |
|
} |
|
// For responsive design, adjust the criterias properties on the following events |
|
this.s.dt.on('draw.dtsp', function () { |
|
_this._adjustCriteria(); |
|
}); |
|
this.s.dt.on('buttons-action', function () { |
|
_this._adjustCriteria(); |
|
}); |
|
$(window).on('resize.dtsp', DataTable.util.throttle(function () { |
|
_this._adjustCriteria(); |
|
})); |
|
this._buildCriteria(); |
|
return this; |
|
} |
|
/** |
|
* Adds the left button to the criteria |
|
*/ |
|
Criteria.prototype.updateArrows = function (hasSiblings, redraw) { |
|
if (hasSiblings === void 0) { hasSiblings = false; } |
|
if (redraw === void 0) { redraw = true; } |
|
// Empty the container and append all of the elements in the correct order |
|
$(this.dom.container) |
|
.empty() |
|
.append(this.dom.data) |
|
.append(this.dom.condition) |
|
.append(this.dom.value[0]); |
|
// Trigger the inserted events for the value elements as they are inserted |
|
$(this.dom.value[0]).trigger('dtsb-inserted'); |
|
for (var i = 1; i < this.dom.value.length; i++) { |
|
$(this.dom.container).append(this.dom.value[i]); |
|
$(this.dom.value[i]).trigger('dtsb-inserted'); |
|
} |
|
// If this is a top level criteria then don't let it move left |
|
if (this.s.depth > 1) { |
|
$(this.dom.buttons).append(this.dom.left); |
|
} |
|
// If the depthLimit of the query has been hit then don't add the right button |
|
if ((this.c.depthLimit === false || this.s.depth < this.c.depthLimit) && hasSiblings) { |
|
$(this.dom.buttons).append(this.dom.right); |
|
} |
|
else { |
|
$(this.dom.right).remove(); |
|
} |
|
$(this.dom.buttons).append(this.dom["delete"]); |
|
$(this.dom.container).append(this.dom.buttons); |
|
if (redraw) { |
|
// A different combination of arrows and selectors may lead to a need for responsive to be triggered |
|
this._adjustCriteria(); |
|
} |
|
}; |
|
/** |
|
* Destroys the criteria, removing listeners and container from the dom |
|
*/ |
|
Criteria.prototype.destroy = function () { |
|
// Turn off listeners |
|
$(this.dom.data).off('.dtsb'); |
|
$(this.dom.condition).off('.dtsb'); |
|
$(this.dom["delete"]).off('.dtsb'); |
|
for (var _i = 0, _a = this.dom.value; _i < _a.length; _i++) { |
|
var val = _a[_i]; |
|
$(val).off('.dtsb'); |
|
} |
|
// Remove container from the dom |
|
$(this.dom.container).remove(); |
|
}; |
|
/** |
|
* Passes in the data for the row and compares it against this single criteria |
|
* @param rowData The data for the row to be compared |
|
* @returns boolean Whether the criteria has passed |
|
*/ |
|
Criteria.prototype.search = function (rowData, rowIdx) { |
|
var condition = this.s.conditions[this.s.condition]; |
|
if (this.s.condition !== undefined && condition !== undefined) { |
|
// This check is in place for if a custom decimal character is in place |
|
if (this.s.type.indexOf('num') !== -1 && this.s.dt.settings()[0].oLanguage.sDecimal !== '') { |
|
rowData[this.s.dataIdx] = rowData[this.s.dataIdx].replace(this.s.dt.settings()[0].oLanguage.sDecimal, '.'); |
|
} |
|
var filter = rowData[this.s.dataIdx]; |
|
// If orthogonal data is in place we need to get it's values for searching |
|
if (this.c.orthogonal.search !== 'search') { |
|
var settings = this.s.dt.settings()[0]; |
|
filter = settings.oApi._fnGetCellData(settings, rowIdx, this.s.dataIdx, typeof this.c.orthogonal === 'string' ? |
|
this.c.orthogonal : |
|
this.c.orthogonal.search); |
|
} |
|
if (this.s.type === 'array') { |
|
// Make sure we are working with an array |
|
if (!Array.isArray(filter)) { |
|
filter = [filter]; |
|
} |
|
filter.sort(); |
|
} |
|
return condition.search(filter, this.s.value, this); |
|
} |
|
}; |
|
/** |
|
* Gets the details required to rebuild the criteria |
|
*/ |
|
Criteria.prototype.getDetails = function () { |
|
var value = this.s.value; |
|
// This check is in place for if a custom decimal character is in place |
|
if (this.s.type.indexOf('num') !== -1 && this.s.dt.settings()[0].oLanguage.sDecimal !== '') { |
|
for (var i = 0; i < this.s.value.length; i++) { |
|
if (this.s.value[i].indexOf('.') !== -1) { |
|
value[i] = this.s.value[i].replace('.', this.s.dt.settings()[0].oLanguage.sDecimal); |
|
} |
|
} |
|
} |
|
return { |
|
condition: this.s.condition, |
|
data: this.s.data, |
|
value: value |
|
}; |
|
}; |
|
/** |
|
* Getter for the node for the container of the criteria |
|
* @returns JQuery<HTMLElement> the node for the container |
|
*/ |
|
Criteria.prototype.getNode = function () { |
|
return this.dom.container; |
|
}; |
|
/** |
|
* Populates the criteria data, condition and value(s) as far as has been selected |
|
*/ |
|
Criteria.prototype.populate = function () { |
|
this._populateData(); |
|
// If the column index has been found attempt to select a condition |
|
if (this.s.dataIdx !== -1) { |
|
this._populateCondition(); |
|
// If the condittion has been found attempt to select the values |
|
if (this.s.condition !== undefined) { |
|
this._populateValue(); |
|
} |
|
} |
|
}; |
|
/** |
|
* Rebuilds the criteria based upon the details passed in |
|
* @param loadedCriteria the details required to rebuild the criteria |
|
*/ |
|
Criteria.prototype.rebuild = function (loadedCriteria) { |
|
// Check to see if the previously selected data exists, if so select it |
|
var foundData = false; |
|
var dataIdx; |
|
this._populateData(); |
|
// If a data selection has previously been made attempt to find and select it |
|
if (loadedCriteria.data !== undefined) { |
|
var italic_1 = this.classes.italic; |
|
var data_1 = this.dom.data; |
|
$(this.dom.data).children('option').each(function () { |
|
if ($(this).text() === loadedCriteria.data) { |
|
$(this).attr('selected', true); |
|
$(data_1).removeClass(italic_1); |
|
foundData = true; |
|
dataIdx = $(this).val(); |
|
} |
|
}); |
|
} |
|
// If the data has been found and selected then the condition can be populated and searched |
|
if (foundData) { |
|
this.s.data = loadedCriteria.data; |
|
this.s.dataIdx = dataIdx; |
|
$(this.dom.dataTitle).remove(); |
|
this._populateCondition(); |
|
$(this.dom.conditionTitle).remove(); |
|
var condition_1; |
|
// Check to see if the previously selected condition exists, if so select it |
|
$(this.dom.condition).children('option').each(function () { |
|
if ((loadedCriteria.condition !== undefined && |
|
$(this).val() === loadedCriteria.condition && |
|
typeof loadedCriteria.condition === 'string')) { |
|
$(this).attr('selected', true); |
|
condition_1 = $(this).val(); |
|
} |
|
}); |
|
this.s.condition = condition_1; |
|
// If the condition has been found and selected then the value can be populated and searched |
|
if (this.s.condition !== undefined) { |
|
$(this.dom.conditionTitle).remove(); |
|
$(this.dom.condition).removeClass(this.classes.italic); |
|
this._populateValue(loadedCriteria); |
|
} |
|
else { |
|
$(this.dom.conditionTitle).prependTo(this.dom.condition).attr('selected', true); |
|
} |
|
} |
|
}; |
|
/** |
|
* Sets the listeners for the criteria |
|
*/ |
|
Criteria.prototype.setListeners = function () { |
|
var _this = this; |
|
$(this.dom.data) |
|
.unbind('input change') |
|
.on('input change', function () { |
|
$(_this.dom.dataTitle).attr('selected', false); |
|
$(_this.dom.data).removeClass(_this.classes.italic); |
|
_this.s.dataIdx = $(_this.dom.data).children('option:selected').val(); |
|
_this.s.data = $(_this.dom.data).children('option:selected').text(); |
|
_this.c.orthogonal = _this._getOptions().orthogonal; |
|
// When the data is changed, the values in condition and value may also change so need to renew them |
|
_this._clearCondition(); |
|
_this._clearValue(); |
|
_this._populateCondition(); |
|
// If this criteria was previously active in the search then remove it from the search and trigger a new search |
|
if (_this.s.filled) { |
|
_this.s.filled = false; |
|
_this.s.dt.draw(); |
|
_this.setListeners(); |
|
} |
|
_this.s.dt.state.save(); |
|
}); |
|
$(this.dom.condition) |
|
.unbind('input change') |
|
.on('input change', function () { |
|
$(_this.dom.conditionTitle).attr('selected', false); |
|
$(_this.dom.condition).removeClass(_this.classes.italic); |
|
var condDisp = $(_this.dom.condition).children('option:selected').val(); |
|
// Find the condition that has been selected and store it internally |
|
for (var _i = 0, _a = Object.keys(_this.s.conditions); _i < _a.length; _i++) { |
|
var cond = _a[_i]; |
|
if (cond === condDisp) { |
|
_this.s.condition = condDisp; |
|
break; |
|
} |
|
} |
|
// When the condition is changed, the value selector may switch between a select element and an input element |
|
_this._clearValue(); |
|
_this._populateValue(); |
|
for (var _b = 0, _c = _this.dom.value; _b < _c.length; _b++) { |
|
var val = _c[_b]; |
|
// If this criteria was previously active in the search then remove it from the search and trigger a new search |
|
if (_this.s.filled && $(_this.dom.container).has(val).length !== 0) { |
|
_this.s.filled = false; |
|
_this.s.dt.draw(); |
|
_this.setListeners(); |
|
} |
|
} |
|
_this.s.dt.draw(); |
|
}); |
|
}; |
|
/** |
|
* Adjusts the criteria to make SearchBuilder responsive |
|
*/ |
|
Criteria.prototype._adjustCriteria = function () { |
|
// If this criteria is not present then don't bother adjusting it |
|
if ($(document).has(this.dom.container).length === 0) { |
|
return; |
|
} |
|
var valRight; |
|
var valWidth; |
|
var outmostval = this.dom.value[this.dom.value.length - 1]; |
|
// Calculate the width and right value of the outmost value element |
|
if ($(this.dom.container).has(outmostval).length !== 0) { |
|
valWidth = $(outmostval).outerWidth(true); |
|
valRight = $(outmostval).offset().left + valWidth; |
|
} |
|
else { |
|
return; |
|
} |
|
var leftOffset = $(this.dom.left).offset(); |
|
var rightOffset = $(this.dom.right).offset(); |
|
var clearOffset = $(this.dom["delete"]).offset(); |
|
var hasLeft = $(this.dom.container).has(this.dom.left).length !== 0; |
|
var hasRight = $(this.dom.container).has(this.dom.right).length !== 0; |
|
var buttonsLeft = hasLeft ? |
|
leftOffset.left : |
|
hasRight ? |
|
rightOffset.left : |
|
clearOffset.left; |
|
// Perform the responsive calculations and redraw where necessary |
|
if (buttonsLeft - valRight < 15 || |
|
(hasLeft && leftOffset.top !== clearOffset.top) || |
|
(hasRight && rightOffset.top !== clearOffset.top)) { |
|
$(this.dom.container).parent().addClass(this.classes.vertical); |
|
$(this.s.topGroup).trigger('dtsb-redrawContents'); |
|
} |
|
else if (buttonsLeft - |
|
($(this.dom.data).offset().left + |
|
$(this.dom.data).outerWidth(true) + |
|
$(this.dom.condition).outerWidth(true) + |
|
valWidth) > 15) { |
|
$(this.dom.container).parent().removeClass(this.classes.vertical); |
|
$(this.s.topGroup).trigger('dtsb-redrawContents'); |
|
} |
|
}; |
|
/** |
|
* Builds the elements of the dom together |
|
*/ |
|
Criteria.prototype._buildCriteria = function () { |
|
// Append Titles for select elements |
|
$(this.dom.data).append(this.dom.dataTitle); |
|
$(this.dom.condition).append(this.dom.conditionTitle); |
|
// Add elements to container |
|
$(this.dom.container) |
|
.append(this.dom.data) |
|
.append(this.dom.condition); |
|
for (var _i = 0, _a = this.dom.value; _i < _a.length; _i++) { |
|
var val = _a[_i]; |
|
$(val).append(this.dom.valueTitle); |
|
$(this.dom.container).append(val); |
|
} |
|
// Add buttons to container |
|
$(this.dom.container) |
|
.append(this.dom["delete"]) |
|
.append(this.dom.right); |
|
this.setListeners(); |
|
}; |
|
/** |
|
* Clears the condition select element |
|
*/ |
|
Criteria.prototype._clearCondition = function () { |
|
$(this.dom.condition).empty(); |
|
$(this.dom.conditionTitle).attr('selected', true).attr('disabled', true); |
|
$(this.dom.condition).prepend(this.dom.conditionTitle).prop('selectedIndex', 0); |
|
this.s.conditions = {}; |
|
this.s.condition = undefined; |
|
}; |
|
/** |
|
* Clears the value elements |
|
*/ |
|
Criteria.prototype._clearValue = function () { |
|
if (this.s.condition !== undefined) { |
|
// Remove all of the value elements |
|
for (var _i = 0, _a = this.dom.value; _i < _a.length; _i++) { |
|
var val = _a[_i]; |
|
$(val).remove(); |
|
} |
|
// Call the init function to get the value elements for this condition |
|
this.dom.value = [].concat(this.s.conditions[this.s.condition].init(this, Criteria.updateListener)); |
|
$(this.dom.value[0]).insertAfter(this.dom.condition).trigger('dtsb-inserted'); |
|
// Insert all of the value elements |
|
for (var i = 1; i < this.dom.value.length; i++) { |
|
$(this.dom.value[i]).insertAfter(this.dom.value[i - 1]).trigger('dtsb-inserted'); |
|
} |
|
} |
|
else { |
|
// Remove all of the value elements |
|
for (var _b = 0, _c = this.dom.value; _b < _c.length; _b++) { |
|
var val = _c[_b]; |
|
$(val).remove(); |
|
} |
|
// Append the default valueTitle to the default select element |
|
$(this.dom.valueTitle) |
|
.attr('selected', true); |
|
$(this.dom.defaultValue) |
|
.append(this.dom.valueTitle) |
|
.insertAfter(this.dom.condition); |
|
} |
|
this.s.value = []; |
|
}; |
|
/** |
|
* Gets the options for the column |
|
* @returns {object} The options for the column |
|
*/ |
|
Criteria.prototype._getOptions = function () { |
|
var table = this.s.dt; |
|
return $.extend(true, {}, Criteria.defaults, table.settings()[0].aoColumns[this.s.dataIdx].searchBuilder); |
|
}; |
|
/** |
|
* Populates the condition dropdown |
|
*/ |
|
Criteria.prototype._populateCondition = function () { |
|
var conditionOpts = []; |
|
var conditionsLength = Object.keys(this.s.conditions).length; |
|
// If there are no conditions stored then we need to get them from the appropriate type |
|
if (conditionsLength === 0) { |
|
var column = $(this.dom.data).children('option:selected').val(); |
|
this.s.type = this.s.dt.columns().type().toArray()[column]; |
|
// If the column type is unknown, call a draw to try reading it again |
|
if (this.s.type === null) { |
|
this.s.dt.draw(); |
|
this.setListeners(); |
|
this.s.type = this.s.dt.columns().type().toArray()[column]; |
|
} |
|
// Enable the condition element |
|
$(this.dom.condition) |
|
.attr('disabled', false) |
|
.empty() |
|
.append(this.dom.conditionTitle) |
|
.addClass(this.classes.italic); |
|
$(this.dom.conditionTitle) |
|
.attr('selected', true); |
|
var decimal = this.s.dt.settings()[0].oLanguage.sDecimal; |
|
// This check is in place for if a custom decimal character is in place |
|
if (decimal !== '' && this.s.type.indexOf(decimal) === this.s.type.length - decimal.length) { |
|
if (this.s.type.indexOf('num-fmt') !== -1) { |
|
this.s.type = this.s.type.replace(decimal, ''); |
|
} |
|
else if (this.s.type.indexOf('num') !== -1) { |
|
this.s.type = this.s.type.replace(decimal, ''); |
|
} |
|
} |
|
// Select which conditions are going to be used based on the column type |
|
var conditionObj = this.c.conditions[this.s.type] !== undefined ? |
|
this.c.conditions[this.s.type] : |
|
this.s.type.indexOf('moment') !== -1 ? |
|
this.c.conditions.moment : |
|
this.c.conditions.string; |
|
// If it is a moment format then extract the date format |
|
if (this.s.type.indexOf('moment') !== -1) { |
|
this.s.momentFormat = this.s.type.replace(/moment\-/g, ''); |
|
} |
|
// Add all of the conditions to the select element |
|
for (var _i = 0, _a = Object.keys(conditionObj); _i < _a.length; _i++) { |
|
var condition = _a[_i]; |
|
if (conditionObj[condition] !== null) { |
|
this.s.conditions[condition] = conditionObj[condition]; |
|
var condName = conditionObj[condition].conditionName; |
|
if (typeof condName === 'function') { |
|
condName = condName(this.s.dt, this.c.i18n); |
|
} |
|
conditionOpts.push($('<option>', { |
|
text: condName, |
|
value: condition |
|
}) |
|
.addClass(this.classes.option) |
|
.addClass(this.classes.notItalic)); |
|
} |
|
} |
|
} |
|
// Otherwise we can just load them in |
|
else if (conditionsLength > 0) { |
|
$(this.dom.condition).empty().attr('disabled', false).addClass(this.classes.italic); |
|
for (var _b = 0, _c = Object.keys(this.s.conditions); _b < _c.length; _b++) { |
|
var condition = _c[_b]; |
|
var condName = this.s.conditions[condition].conditionName; |
|
if (typeof condName === 'function') { |
|
condName = condName(this.s.dt, this.c.i18n); |
|
} |
|
var newOpt = $('<option>', { |
|
text: condName, |
|
value: condition |
|
}) |
|
.addClass(this.classes.option) |
|
.addClass(this.classes.notItalic); |
|
if (this.s.condition !== undefined && this.s.condition === condName) { |
|
$(newOpt).attr('selected', true); |
|
$(this.dom.condition).removeClass(this.classes.italic); |
|
} |
|
conditionOpts.push(newOpt); |
|
} |
|
} |
|
else { |
|
$(this.dom.condition) |
|
.attr('disabled', true) |
|
.addClass(this.classes.italic); |
|
return; |
|
} |
|
for (var _d = 0, conditionOpts_1 = conditionOpts; _d < conditionOpts_1.length; _d++) { |
|
var opt = conditionOpts_1[_d]; |
|
$(this.dom.condition).append(opt); |
|
} |
|
$(this.dom.condition).prop('selectedIndex', 0); |
|
}; |
|
/** |
|
* Populates the data select element |
|
*/ |
|
Criteria.prototype._populateData = function () { |
|
var _this = this; |
|
$(this.dom.data).empty().append(this.dom.dataTitle); |
|
// If there are no datas stored then we need to get them from the table |
|
if (this.s.dataPoints.length === 0) { |
|
this.s.dt.columns().every(function (index) { |
|
// Need to check that the column can be filtered on before adding it |
|
if (_this.c.columns === true || |
|
(_this.s.dt.columns(_this.c.columns).indexes().toArray().indexOf(index) !== -1)) { |
|
var found = false; |
|
for (var _i = 0, _a = _this.s.dataPoints; _i < _a.length; _i++) { |
|
var val = _a[_i]; |
|
if (val.index === index) { |
|
found = true; |
|
break; |
|
} |
|
} |
|
if (!found) { |
|
var opt = { text: _this.s.dt.settings()[0].aoColumns[index].sTitle, index: index }; |
|
_this.s.dataPoints.push(opt); |
|
$(_this.dom.data).append($('<option>', { |
|
text: opt.text, |
|
value: opt.index |
|
}) |
|
.addClass(_this.classes.option) |
|
.addClass(_this.classes.notItalic)); |
|
} |
|
} |
|
}); |
|
} |
|
// Otherwise we can just load them in |
|
else { |
|
var _loop_1 = function (data) { |
|
this_1.s.dt.columns().every(function (index) { |
|
if (_this.s.dt.settings()[0].aoColumns[index].sTitle === data.text) { |
|
data.index = index; |
|
} |
|
}); |
|
var newOpt = $('<option>', { |
|
text: data.text, |
|
value: data.index |
|
}) |
|
.addClass(this_1.classes.option) |
|
.addClass(this_1.classes.notItalic); |
|
if (this_1.s.data === data.text) { |
|
this_1.s.dataIdx = data.index; |
|
$(newOpt).attr('selected', true); |
|
$(this_1.dom.data).removeClass(this_1.classes.italic); |
|
} |
|
$(this_1.dom.data).append(newOpt); |
|
}; |
|
var this_1 = this; |
|
for (var _i = 0, _a = this.s.dataPoints; _i < _a.length; _i++) { |
|
var data = _a[_i]; |
|
_loop_1(data); |
|
} |
|
} |
|
}; |
|
/** |
|
* Populates the Value select element |
|
* @param loadedCriteria optional, used to reload criteria from predefined filters |
|
*/ |
|
Criteria.prototype._populateValue = function (loadedCriteria) { |
|
var _this = this; |
|
var prevFilled = this.s.filled; |
|
this.s.filled = false; |
|
// Remove any previous value elements |
|
$(this.dom.defaultValue).remove(); |
|
for (var _i = 0, _a = this.dom.value; _i < _a.length; _i++) { |
|
var val = _a[_i]; |
|
$(val).remove(); |
|
} |
|
var children = $(this.dom.container).children(); |
|
if (children.length > 3) { |
|
for (var i = 2; i < children.length - 1; i++) { |
|
$(children[i]).remove(); |
|
} |
|
} |
|
// Find the column with the title matching the data for the criteria and take note of the index |
|
if (loadedCriteria !== undefined) { |
|
this.s.dt.columns().every(function (index) { |
|
if (_this.s.dt.settings()[0].aoColumns[index].sTitle === loadedCriteria.data) { |
|
_this.s.dataIdx = index; |
|
} |
|
}); |
|
} |
|
// Initialise the value elements based on the condition |
|
this.dom.value = [].concat(this.s.conditions[this.s.condition].init(this, Criteria.updateListener, loadedCriteria !== undefined ? loadedCriteria.value : undefined)); |
|
if (loadedCriteria !== undefined && loadedCriteria.value !== undefined) { |
|
this.s.value = loadedCriteria.value; |
|
} |
|
// Insert value elements and trigger the inserted event |
|
$(this.dom.value[0]) |
|
.insertAfter(this.dom.condition) |
|
.trigger('dtsb-inserted'); |
|
for (var i = 1; i < this.dom.value.length; i++) { |
|
$(this.dom.value[i]) |
|
.insertAfter(this.dom.value[i - 1]) |
|
.trigger('dtsb-inserted'); |
|
} |
|
// Check if the criteria can be used in a search |
|
this.s.filled = this.s.conditions[this.s.condition].isInputValid(this.dom.value, this); |
|
this.setListeners(); |
|
// If it can and this is different to before then trigger a draw |
|
if (prevFilled !== this.s.filled) { |
|
this.s.dt.draw(); |
|
this.setListeners(); |
|
} |
|
}; |
|
Criteria.version = '1.0.0'; |
|
Criteria.classes = { |
|
button: 'dtsb-button', |
|
buttonContainer: 'dtsb-buttonContainer', |
|
condition: 'dtsb-condition', |
|
container: 'dtsb-criteria', |
|
data: 'dtsb-data', |
|
"delete": 'dtsb-delete', |
|
dropDown: 'dtsb-dropDown', |
|
greyscale: 'dtsb-greyscale', |
|
input: 'dtsb-input', |
|
italic: 'dtsb-italic', |
|
joiner: 'dtsp-joiner', |
|
left: 'dtsb-left', |
|
notItalic: 'dtsb-notItalic', |
|
option: 'dtsb-option', |
|
right: 'dtsb-right', |
|
value: 'dtsb-value', |
|
vertical: 'dtsb-vertical' |
|
}; |
|
/** |
|
* Default initialisation function for select conditions |
|
*/ |
|
Criteria.initSelect = function (that, fn, preDefined, array) { |
|
if (preDefined === void 0) { preDefined = null; } |
|
if (array === void 0) { array = false; } |
|
var column = $(that.dom.data).children('option:selected').val(); |
|
var indexArray = that.s.dt.rows().indexes().toArray(); |
|
var settings = that.s.dt.settings()[0]; |
|
// Declare select element to be used with all of the default classes and listeners. |
|
var el = $('<select/>') |
|
.addClass(Criteria.classes.value) |
|
.addClass(Criteria.classes.dropDown) |
|
.addClass(Criteria.classes.italic) |
|
.append(that.dom.valueTitle) |
|
.on('input change', function () { |
|
$(this).removeClass(Criteria.classes.italic); |
|
fn(that, this); |
|
}); |
|
if (that.c.greyscale) { |
|
$(el).addClass(Criteria.classes.greyscale); |
|
} |
|
var added = []; |
|
var options = []; |
|
// Add all of the options from the table to the select element. |
|
// Only add one option for each possible value |
|
for (var _i = 0, indexArray_1 = indexArray; _i < indexArray_1.length; _i++) { |
|
var index = indexArray_1[_i]; |
|
var filter = settings.oApi._fnGetCellData(settings, index, column, typeof that.c.orthogonal === 'string' ? |
|
that.c.orthogonal : |
|
that.c.orthogonal.search); |
|
var value = { |
|
filter: typeof filter === 'string' ? |
|
filter.replace(/[\r\n\u2028]/g, ' ') : // Need to replace certain characters to match the search values |
|
filter, |
|
index: index, |
|
text: settings.oApi._fnGetCellData(settings, index, column, typeof that.c.orthogonal === 'string' ? |
|
that.c.orthogonal : |
|
that.c.orthogonal.display) |
|
}; |
|
// If we are dealing with an array type, either make sure we are working with arrays, or sort them |
|
if (that.s.type === 'array') { |
|
value.filter = !Array.isArray(value.filter) ? |
|
[value.filter] : |
|
value.filter = value.filter.sort(); |
|
value.text = !Array.isArray(value.text) ? |
|
[value.text] : |
|
value.text = value.text.sort(); |
|
} |
|
// Function to add an option to the select element |
|
var addOption = function (filt, text) { |
|
// Add text and value, stripping out any html if that is the column type |
|
var opt = $('<option>', { |
|
text: typeof text === 'string' ? |
|
text.replace(/(<([^>]+)>)/ig, '') : |
|
text, |
|
type: Array.isArray(filt) ? 'Array' : 'String', |
|
value: that.s.type.indexOf('html') !== -1 && filt !== null && typeof filt === 'string' ? |
|
filt.replace(/(<([^>]+)>)/ig, '') : |
|
filt |
|
}) |
|
.addClass(that.classes.option) |
|
.addClass(that.classes.notItalic); |
|
var val = $(opt).val(); |
|
// Check that this value has not already been added |
|
if (added.indexOf(val) === -1) { |
|
added.push(val); |
|
options.push(opt); |
|
if (preDefined !== null && Array.isArray(preDefined[0])) { |
|
preDefined[0] = preDefined[0].sort().join(','); |
|
} |
|
// If this value was previously selected as indicated by preDefined, then select it again |
|
if (preDefined !== null && opt.val() === preDefined[0]) { |
|
opt.attr('selected', true); |
|
$(el).removeClass(Criteria.classes.italic); |
|
} |
|
} |
|
}; |
|
// If this is to add the individual values within the array we need to loop over the array |
|
if (array) { |
|
for (var i = 0; i < value.filter.length; i++) { |
|
addOption(value.filter[i], value.text[i]); |
|
} |
|
} |
|
// Otherwise the value that is in the cell is to be added |
|
else { |
|
addOption(value.filter, value.text); |
|
} |
|
} |
|
options.sort(function (a, b) { |
|
if (that.s.type === 'string' || that.s.type === 'num' || that.s.type === 'html' || that.s.type === 'html-num') { |
|
if ($(a).val() < $(b).val()) { |
|
return -1; |
|
} |
|
else if ($(a).val() < $(b).val()) { |
|
return 1; |
|
} |
|
else { |
|
return 0; |
|
} |
|
} |
|
else if (that.s.type === 'num-fmt' || that.s.type === 'html-num-fmt') { |
|
if (+$(a).val().replace(/[^0-9.]/g, '') < +$(b).val().replace(/[^0-9.]/g, '')) { |
|
return -1; |
|
} |
|
else if (+$(a).val().replace(/[^0-9.]/g, '') < +$(b).val().replace(/[^0-9.]/g, '')) { |
|
return 1; |
|
} |
|
else { |
|
return 0; |
|
} |
|
} |
|
}); |
|
for (var _a = 0, options_1 = options; _a < options_1.length; _a++) { |
|
var opt = options_1[_a]; |
|
$(el).append(opt); |
|
} |
|
return el; |
|
}; |
|
/** |
|
* Default initialisation function for select array conditions |
|
* |
|
* This exists because there needs to be different select functionality for contains/without and equals/not |
|
*/ |
|
Criteria.initSelectArray = function (that, fn, preDefined) { |
|
if (preDefined === void 0) { preDefined = null; } |
|
return Criteria.initSelect(that, fn, preDefined, true); |
|
}; |
|
/** |
|
* Default initialisation function for input conditions |
|
*/ |
|
Criteria.initInput = function (that, fn, preDefined) { |
|
if (preDefined === void 0) { preDefined = null; } |
|
// Declare the input element |
|
var el = $('<input/>') |
|
.addClass(Criteria.classes.value) |
|
.addClass(Criteria.classes.input) |
|
.on('input', function () { fn(that, this); }); |
|
if (that.c.greyscale) { |
|
$(el).addClass(Criteria.classes.greyscale); |
|
} |
|
// If there is a preDefined value then add it |
|
if (preDefined !== null) { |
|
$(el).val(preDefined[0]); |
|
} |
|
return el; |
|
}; |
|
/** |
|
* Default initialisation function for conditions requiring 2 inputs |
|
*/ |
|
Criteria.init2Input = function (that, fn, preDefined) { |
|
if (preDefined === void 0) { preDefined = null; } |
|
// Declare all of the necessary jQuery elements |
|
var els = [ |
|
$('<input/>') |
|
.addClass(Criteria.classes.value) |
|
.addClass(Criteria.classes.input) |
|
.on('input', function () { fn(that, this); }), |
|
$('<span>') |
|
.addClass(that.classes.joiner).text(that.s.dt.i18n('searchBuilder.valueJoiner', that.c.i18n.valueJoiner)), |
|
$('<input/>') |
|
.addClass(Criteria.classes.value) |
|
.addClass(Criteria.classes.input) |
|
.on('input', function () { fn(that, this); }) |
|
]; |
|
if (that.c.greyscale) { |
|
$(els[0]).addClass(Criteria.classes.greyscale); |
|
$(els[2]).addClass(Criteria.classes.greyscale); |
|
} |
|
// If there is a preDefined value then add it |
|
if (preDefined !== null) { |
|
$(els[0]).val(preDefined[0]); |
|
$(els[2]).val(preDefined[1]); |
|
} |
|
that.s.dt.off('draw'); |
|
that.s.dt.one('draw', function () { |
|
$(that.s.topGroup).trigger('dtsb-redrawContents'); |
|
}); |
|
return els; |
|
}; |
|
/** |
|
* Default initialisation function for date conditions |
|
*/ |
|
Criteria.initDate = function (that, fn, preDefined) { |
|
if (preDefined === void 0) { preDefined = null; } |
|
// Declare date element using DataTables dateTime plugin |
|
var el = $('<input/>') |
|
.addClass(Criteria.classes.value) |
|
.addClass(Criteria.classes.input) |
|
.dtDateTime({ |
|
attachTo: 'input', |
|
format: that.s.momentFormat ? that.s.momentFormat : undefined |
|
}) |
|
.on('input change', function () { fn(that, this); }); |
|
if (that.c.greyscale) { |
|
$(el).addClass(Criteria.classes.greyscale); |
|
} |
|
// If there is a preDefined value then add it |
|
if (preDefined !== null) { |
|
$(el).val(preDefined[0]); |
|
} |
|
return el; |
|
}; |
|
Criteria.initNoValue = function (that) { |
|
that.s.dt.off('draw'); |
|
that.s.dt.one('draw', function () { |
|
$(that.s.topGroup).trigger('dtsb-redrawContents'); |
|
}); |
|
}; |
|
Criteria.init2Date = function (that, fn, preDefined) { |
|
if (preDefined === void 0) { preDefined = null; } |
|
// Declare all of the date elements that are required using DataTables dateTime plugin |
|
var els = [ |
|
$('<input/>') |
|
.addClass(Criteria.classes.value) |
|
.addClass(Criteria.classes.input) |
|
.dtDateTime({ |
|
attachTo: 'input', |
|
format: that.s.momentFormat ? that.s.momentFormat : undefined |
|
}) |
|
.on('input change', function () { fn(that, this); }), |
|
$('<span>') |
|
.addClass(that.classes.joiner) |
|
.text(that.s.dt.i18n('searchBuilder.valueJoiner', that.c.i18n.valueJoiner)), |
|
$('<input/>') |
|
.addClass(Criteria.classes.value) |
|
.addClass(Criteria.classes.input) |
|
.dtDateTime({ |
|
attachTo: 'input', |
|
format: that.s.momentFormat ? that.s.momentFormat : undefined |
|
}) |
|
.on('input change', function () { fn(that, this); }) |
|
]; |
|
if (that.c.greyscale) { |
|
$(els[0]).addClass(Criteria.classes.greyscale); |
|
$(els[2]).addClass(Criteria.classes.greyscale); |
|
} |
|
// If there are and preDefined values then add them |
|
if (preDefined !== null && preDefined.length > 0) { |
|
$(els[0]).val(preDefined[0]); |
|
$(els[2]).val(preDefined[1]); |
|
} |
|
that.s.dt.off('draw'); |
|
that.s.dt.one('draw', function () { |
|
$(that.s.topGroup).trigger('dtsb-redrawContents'); |
|
}); |
|
return els; |
|
}; |
|
/** |
|
* Default function for select elements to validate condition |
|
*/ |
|
Criteria.isInputValidSelect = function (el) { |
|
var allFilled = true; |
|
// Check each element to make sure that the selections are valid |
|
for (var _i = 0, el_1 = el; _i < el_1.length; _i++) { |
|
var element = el_1[_i]; |
|
if ($(element).children('option:selected').length === $(element).children('option').length - $(element).children('option.' + Criteria.classes.notItalic).length && |
|
$(element).children('option:selected').length === 1 && |
|
$(element).children('option:selected')[0] === $(element).children('option:hidden')[0]) { |
|
allFilled = false; |
|
} |
|
} |
|
return allFilled; |
|
}; |
|
/** |
|
* Default function for input and date elements to validate condition |
|
*/ |
|
Criteria.isInputValidInput = function (el) { |
|
var allFilled = true; |
|
// Check each element to make sure that the inputs are valid |
|
for (var _i = 0, el_2 = el; _i < el_2.length; _i++) { |
|
var element = el_2[_i]; |
|
if ($(element).is('input') && $(element).val().length === 0) { |
|
allFilled = false; |
|
} |
|
} |
|
return allFilled; |
|
}; |
|
/** |
|
* Default function for getting select conditions |
|
*/ |
|
Criteria.inputValueSelect = function (el) { |
|
var values = []; |
|
// Go through the select elements and push each selected option to the return array |
|
for (var _i = 0, el_3 = el; _i < el_3.length; _i++) { |
|
var element = el_3[_i]; |
|
if ($(element).is('select')) { |
|
var val = $(element).children('option:selected').val(); |
|
// If the type of the option is an array we need to split it up and sort it |
|
values.push($(element).children('option:selected').attr('type') === 'Array' ? |
|
val.split(',').sort() : |
|
val); |
|
} |
|
} |
|
return values; |
|
}; |
|
/** |
|
* Default function for getting input conditions |
|
*/ |
|
Criteria.inputValueInput = function (el) { |
|
var values = []; |
|
// Go through the input elements and push each value to the return array |
|
for (var _i = 0, el_4 = el; _i < el_4.length; _i++) { |
|
var element = el_4[_i]; |
|
if ($(element).is('input')) { |
|
values.push($(element).val()); |
|
} |
|
} |
|
return values; |
|
}; |
|
/** |
|
* Function that is run on each element as a call back when a search should be triggered |
|
*/ |
|
Criteria.updateListener = function (that, el) { |
|
// When the value is changed the criteria is now complete so can be included in searches |
|
// Get the condition from the map based on the key that has been selected for the condition |
|
var condition = that.s.conditions[that.s.condition]; |
|
that.s.filled = condition.isInputValid(that.dom.value, that); |
|
that.s.value = condition.inputValue(that.dom.value, that); |
|
if (!Array.isArray(that.s.value)) { |
|
that.s.value = [that.s.value]; |
|
} |
|
for (var i = 0; i < that.s.value.length; i++) { |
|
// If the value is an array we need to sort it |
|
if (Array.isArray(that.s.value[i])) { |
|
that.s.value[i].sort(); |
|
} |
|
// Otherwise replace the decimal place character for i18n |
|
else if (that.s.dt.settings()[0].oLanguage.sDecimal !== '') { |
|
that.s.value[i] = that.s.value[i].replace(that.s.dt.settings()[0].oLanguage.sDecimal, '.'); |
|
} |
|
} |
|
// Take note of the cursor position so that we can refocus there later |
|
var idx = null; |
|
var cursorPos = null; |
|
for (var i = 0; i < that.dom.value.length; i++) { |
|
if (el === that.dom.value[i][0]) { |
|
idx = i; |
|
if (el.selectionStart !== undefined) { |
|
cursorPos = el.selectionStart; |
|
} |
|
} |
|
} |
|
// Trigger a search |
|
that.s.dt.draw(); |
|
// Refocus the element and set the correct cursor position |
|
if (idx !== null) { |
|
$(that.dom.value[idx]).removeClass(that.classes.italic); |
|
$(that.dom.value[idx]).focus(); |
|
if (cursorPos !== null) { |
|
$(that.dom.value[idx])[0].setSelectionRange(cursorPos, cursorPos); |
|
} |
|
} |
|
}; |
|
// The order of the conditions will make tslint sad :( |
|
Criteria.dateConditions = { |
|
'=': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.date.equals', i18n.conditions.date.equals); |
|
}, |
|
init: Criteria.initDate, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
value = value.replace(/(\/|\-|\,)/g, '-'); |
|
return value === comparison[0]; |
|
} |
|
}, |
|
'!=': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.date.not', i18n.conditions.date.not); |
|
}, |
|
init: Criteria.initDate, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
value = value.replace(/(\/|\-|\,)/g, '-'); |
|
return value !== comparison[0]; |
|
} |
|
}, |
|
'<': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.date.before', i18n.conditions.date.before); |
|
}, |
|
init: Criteria.initDate, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
value = value.replace(/(\/|\-|\,)/g, '-'); |
|
return value < comparison[0]; |
|
} |
|
}, |
|
'>': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.date.after', i18n.conditions.date.after); |
|
}, |
|
init: Criteria.initDate, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
value = value.replace(/(\/|\-|\,)/g, '-'); |
|
return value > comparison[0]; |
|
} |
|
}, |
|
'between': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.date.between', i18n.conditions.date.between); |
|
}, |
|
init: Criteria.init2Date, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
value = value.replace(/(\/|\-|\,)/g, '-'); |
|
if (comparison[0] < comparison[1]) { |
|
return comparison[0] <= value && value <= comparison[1]; |
|
} |
|
else { |
|
return comparison[1] <= value && value <= comparison[0]; |
|
} |
|
} |
|
}, |
|
'!between': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.date.notBetween', i18n.conditions.date.notBetween); |
|
}, |
|
init: Criteria.init2Date, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
value = value.replace(/(\/|\-|\,)/g, '-'); |
|
if (comparison[0] < comparison[1]) { |
|
return !(comparison[0] <= value && value <= comparison[1]); |
|
} |
|
else { |
|
return !(comparison[1] <= value && value <= comparison[0]); |
|
} |
|
} |
|
}, |
|
'null': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.date.empty', i18n.conditions.date.empty); |
|
}, |
|
isInputValid: function () { return true; }, |
|
init: Criteria.initNoValue, |
|
inputValue: function () { |
|
return; |
|
}, |
|
search: function (value) { |
|
return (value === null || value === undefined || value.length === 0); |
|
} |
|
}, |
|
'!null': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.date.notEmpty', i18n.conditions.date.notEmpty); |
|
}, |
|
isInputValid: function () { return true; }, |
|
init: Criteria.initNoValue, |
|
inputValue: function () { |
|
return; |
|
}, |
|
search: function (value) { |
|
return !(value === null || value === undefined || value.length === 0); |
|
} |
|
} |
|
}; |
|
// The order of the conditions will make tslint sad :( |
|
Criteria.momentDateConditions = { |
|
'=': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.moment.equals', i18n.conditions.moment.equals); |
|
}, |
|
init: Criteria.initDate, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison, that) { |
|
return moment(value, that.s.momentFormat).valueOf() === moment(comparison[0], that.s.momentFormat).valueOf(); |
|
} |
|
}, |
|
'!=': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.moment.not', i18n.conditions.moment.not); |
|
}, |
|
init: Criteria.initDate, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison, that) { |
|
return moment(value, that.s.momentFormat).valueOf() !== moment(comparison[0], that.s.momentFormat).valueOf(); |
|
} |
|
}, |
|
'<': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.moment.before', i18n.conditions.moment.before); |
|
}, |
|
init: Criteria.initDate, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison, that) { |
|
return moment(value, that.s.momentFormat).valueOf() < moment(comparison[0], that.s.momentFormat).valueOf(); |
|
} |
|
}, |
|
'>': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.moment.after', i18n.conditions.moment.after); |
|
}, |
|
init: Criteria.initDate, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison, that) { |
|
return moment(value, that.s.momentFormat).valueOf() > moment(comparison[0], that.s.momentFormat).valueOf(); |
|
} |
|
}, |
|
'between': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.moment.between', i18n.conditions.moment.between); |
|
}, |
|
init: Criteria.init2Date, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison, that) { |
|
var val = moment(value, that.s.momentFormat).valueOf(); |
|
var comp0 = moment(comparison[0], that.s.momentFormat).valueOf(); |
|
var comp1 = moment(comparison[1], that.s.momentFormat).valueOf(); |
|
if (comp0 < comp1) { |
|
return comp0 <= val && val <= comp1; |
|
} |
|
else { |
|
return comp1 <= val && val <= comp0; |
|
} |
|
} |
|
}, |
|
'!between': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.moment.notBetween', i18n.conditions.moment.notBetween); |
|
}, |
|
init: Criteria.init2Date, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison, that) { |
|
var val = moment(value, that.s.momentFormat).valueOf(); |
|
var comp0 = moment(comparison[0], that.s.momentFormat).valueOf(); |
|
var comp1 = moment(comparison[1], that.s.momentFormat).valueOf(); |
|
if (comp0 < comp1) { |
|
return !(+comp0 <= +val && +val <= +comp1); |
|
} |
|
else { |
|
return !(+comp1 <= +val && +val <= +comp0); |
|
} |
|
} |
|
}, |
|
'null': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.moment.empty', i18n.conditions.moment.empty); |
|
}, |
|
isInputValid: function () { return true; }, |
|
init: Criteria.initNoValue, |
|
inputValue: function () { |
|
return; |
|
}, |
|
search: function (value) { |
|
return (value === null || value === undefined || value.length === 0); |
|
} |
|
}, |
|
'!null': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.moment.notEmpty', i18n.conditions.moment.notEmpty); |
|
}, |
|
isInputValid: function () { return true; }, |
|
init: Criteria.initNoValue, |
|
inputValue: function () { |
|
return; |
|
}, |
|
search: function (value) { |
|
return !(value === null || value === undefined || value.length === 0); |
|
} |
|
} |
|
}; |
|
// The order of the conditions will make tslint sad :( |
|
Criteria.numConditions = { |
|
'=': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.equals', i18n.conditions.number.equals); |
|
}, |
|
init: Criteria.initSelect, |
|
inputValue: Criteria.inputValueSelect, |
|
isInputValid: Criteria.isInputValidSelect, |
|
search: function (value, comparison) { |
|
return +value === +comparison[0]; |
|
} |
|
}, |
|
'!=': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.not', i18n.conditions.number.not); |
|
}, |
|
init: Criteria.initSelect, |
|
inputValue: Criteria.inputValueSelect, |
|
isInputValid: Criteria.isInputValidSelect, |
|
search: function (value, comparison) { |
|
return +value !== +comparison[0]; |
|
} |
|
}, |
|
'<': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.lt', i18n.conditions.number.lt); |
|
}, |
|
init: Criteria.initInput, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
return +value < +comparison[0]; |
|
} |
|
}, |
|
'<=': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.lte', i18n.conditions.number.lte); |
|
}, |
|
init: Criteria.initInput, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
return +value <= +comparison[0]; |
|
} |
|
}, |
|
'>=': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.gte', i18n.conditions.number.gte); |
|
}, |
|
init: Criteria.initInput, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
return +value >= +comparison[0]; |
|
} |
|
}, |
|
'>': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.gt', i18n.conditions.number.gt); |
|
}, |
|
init: Criteria.initInput, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
return +value > +comparison[0]; |
|
} |
|
}, |
|
'between': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.between', i18n.conditions.number.between); |
|
}, |
|
init: Criteria.init2Input, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
if (+comparison[0] < +comparison[1]) { |
|
return +comparison[0] <= +value && +value <= +comparison[1]; |
|
} |
|
else { |
|
return +comparison[1] <= +value && +value <= +comparison[0]; |
|
} |
|
} |
|
}, |
|
'!between': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.notBetween', i18n.conditions.number.notBetween); |
|
}, |
|
init: Criteria.init2Input, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
if (+comparison[0] < +comparison[1]) { |
|
return !(+comparison[0] <= +value && +value <= +comparison[1]); |
|
} |
|
else { |
|
return !(+comparison[1] <= +value && +value <= +comparison[0]); |
|
} |
|
} |
|
}, |
|
'null': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.empty', i18n.conditions.number.empty); |
|
}, |
|
init: Criteria.initNoValue, |
|
inputValue: function () { return; }, |
|
isInputValid: function () { return true; }, |
|
search: function (value) { |
|
return (value === null || value === undefined || value.length === 0); |
|
} |
|
}, |
|
'!null': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.notEmpty', i18n.conditions.number.notEmpty); |
|
}, |
|
isInputValid: function () { return true; }, |
|
init: Criteria.initNoValue, |
|
inputValue: function () { |
|
return; |
|
}, |
|
search: function (value) { |
|
return !(value === null || value === undefined || value.length === 0); |
|
} |
|
} |
|
}; |
|
// The order of the conditions will make tslint sad :( |
|
Criteria.numFmtConditions = { |
|
'=': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.equals', i18n.conditions.number.equals); |
|
}, |
|
init: Criteria.initSelect, |
|
inputValue: Criteria.inputValueSelect, |
|
isInputValid: Criteria.isInputValidSelect, |
|
search: function (value, comparison) { |
|
var val = value.indexOf('-') === 0 ? |
|
'-' + value.replace(/[^0-9.]/g, '') : |
|
value.replace(/[^0-9.]/g, ''); |
|
var comp = comparison[0].indexOf('-') === 0 ? |
|
'-' + comparison[0].replace(/[^0-9.]/g, '') : |
|
comparison[0].replace(/[^0-9.]/g, ''); |
|
return +val === +comp; |
|
} |
|
}, |
|
'!=': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.not', i18n.conditions.number.not); |
|
}, |
|
init: Criteria.initSelect, |
|
inputValue: Criteria.inputValueSelect, |
|
isInputValid: Criteria.isInputValidSelect, |
|
search: function (value, comparison) { |
|
var val = value.indexOf('-') === 0 ? |
|
'-' + value.replace(/[^0-9.]/g, '') : |
|
value.replace(/[^0-9.]/g, ''); |
|
var comp = comparison[0].indexOf('-') === 0 ? |
|
'-' + comparison[0].replace(/[^0-9.]/g, '') : |
|
comparison[0].replace(/[^0-9.]/g, ''); |
|
return +val !== +comp; |
|
} |
|
}, |
|
'<': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.lt', i18n.conditions.number.lt); |
|
}, |
|
init: Criteria.initInput, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
var val = value.indexOf('-') === 0 ? |
|
'-' + value.replace(/[^0-9.]/g, '') : |
|
value.replace(/[^0-9.]/g, ''); |
|
var comp = comparison[0].indexOf('-') === 0 ? |
|
'-' + comparison[0].replace(/[^0-9.]/g, '') : |
|
comparison[0].replace(/[^0-9.]/g, ''); |
|
return +val < +comp; |
|
} |
|
}, |
|
'<=': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.lte', i18n.conditions.number.lte); |
|
}, |
|
init: Criteria.initInput, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
var val = value.indexOf('-') === 0 ? |
|
'-' + value.replace(/[^0-9.]/g, '') : |
|
value.replace(/[^0-9.]/g, ''); |
|
var comp = comparison[0].indexOf('-') === 0 ? |
|
'-' + comparison[0].replace(/[^0-9.]/g, '') : |
|
comparison[0].replace(/[^0-9.]/g, ''); |
|
return +val <= +comp; |
|
} |
|
}, |
|
'>=': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.gte', i18n.conditions.number.gte); |
|
}, |
|
init: Criteria.initInput, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
var val = value.indexOf('-') === 0 ? |
|
'-' + value.replace(/[^0-9.]/g, '') : |
|
value.replace(/[^0-9.]/g, ''); |
|
var comp = comparison[0].indexOf('-') === 0 ? |
|
'-' + comparison[0].replace(/[^0-9.]/g, '') : |
|
comparison[0].replace(/[^0-9.]/g, ''); |
|
return +val >= +comp; |
|
} |
|
}, |
|
'>': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.gt', i18n.conditions.number.gt); |
|
}, |
|
init: Criteria.initInput, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
var val = value.indexOf('-') === 0 ? |
|
'-' + value.replace(/[^0-9.]/g, '') : |
|
value.replace(/[^0-9.]/g, ''); |
|
var comp = comparison[0].indexOf('-') === 0 ? |
|
'-' + comparison[0].replace(/[^0-9.]/g, '') : |
|
comparison[0].replace(/[^0-9.]/g, ''); |
|
return +val > +comp; |
|
} |
|
}, |
|
'between': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.between', i18n.conditions.number.between); |
|
}, |
|
init: Criteria.init2Input, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
var val = value.indexOf('-') === 0 ? |
|
'-' + value.replace(/[^0-9.]/g, '') : |
|
value.replace(/[^0-9.]/g, ''); |
|
var comp0 = comparison[0].indexOf('-') === 0 ? |
|
'-' + comparison[0].replace(/[^0-9.]/g, '') : |
|
comparison[0].replace(/[^0-9.]/g, ''); |
|
var comp1 = comparison[1].indexOf('-') === 0 ? |
|
'-' + comparison[1].replace(/[^0-9.]/g, '') : |
|
comparison[1].replace(/[^0-9.]/g, ''); |
|
if (+comp0 < +comp1) { |
|
return +comp0 <= +val && +val <= +comp1; |
|
} |
|
else { |
|
return +comp1 <= +val && +val <= +comp0; |
|
} |
|
} |
|
}, |
|
'!between': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.notBetween', i18n.conditions.number.notBetween); |
|
}, |
|
init: Criteria.init2Input, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
var val = value.indexOf('-') === 0 ? |
|
'-' + value.replace(/[^0-9.]/g, '') : |
|
value.replace(/[^0-9.]/g, ''); |
|
var comp0 = comparison[0].indexOf('-') === 0 ? |
|
'-' + comparison[0].replace(/[^0-9.]/g, '') : |
|
comparison[0].replace(/[^0-9.]/g, ''); |
|
var comp1 = comparison[1].indexOf('-') === 0 ? |
|
'-' + comparison[1].replace(/[^0-9.]/g, '') : |
|
comparison[1].replace(/[^0-9.]/g, ''); |
|
if (+comp0 < +comp1) { |
|
return !(+comp0 <= +val && +val <= +comp1); |
|
} |
|
else { |
|
return !(+comp1 <= +val && +val <= +comp0); |
|
} |
|
} |
|
}, |
|
'null': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.empty', i18n.conditions.number.empty); |
|
}, |
|
init: Criteria.initNoValue, |
|
inputValue: function () { return; }, |
|
isInputValid: function () { return true; }, |
|
search: function (value) { |
|
return (value === null || value === undefined || value.length === 0); |
|
} |
|
}, |
|
'!null': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.number.notEmpty', i18n.conditions.number.notEmpty); |
|
}, |
|
isInputValid: function () { return true; }, |
|
init: Criteria.initNoValue, |
|
inputValue: function () { |
|
return; |
|
}, |
|
search: function (value) { |
|
return !(value === null || value === undefined || value.length === 0); |
|
} |
|
} |
|
}; |
|
// The order of the conditions will make tslint sad :( |
|
Criteria.stringConditions = { |
|
'=': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.string.equals', i18n.conditions.string.equals); |
|
}, |
|
init: Criteria.initSelect, |
|
inputValue: Criteria.inputValueSelect, |
|
isInputValid: Criteria.isInputValidSelect, |
|
search: function (value, comparison) { |
|
return value === comparison[0]; |
|
} |
|
}, |
|
'!=': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.string.not', i18n.conditions.string.not); |
|
}, |
|
init: Criteria.initSelect, |
|
inputValue: Criteria.inputValueSelect, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
return value !== comparison[0]; |
|
} |
|
}, |
|
'starts': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.string.startsWith', i18n.conditions.string.startsWith); |
|
}, |
|
init: Criteria.initInput, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
return value.toLowerCase().indexOf(comparison[0].toLowerCase()) === 0; |
|
} |
|
}, |
|
'contains': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.string.contains', i18n.conditions.string.contains); |
|
}, |
|
init: Criteria.initInput, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
return value.toLowerCase().indexOf(comparison[0].toLowerCase()) !== -1; |
|
} |
|
}, |
|
'ends': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.string.endsWith', i18n.conditions.string.endsWith); |
|
}, |
|
init: Criteria.initInput, |
|
inputValue: Criteria.inputValueInput, |
|
isInputValid: Criteria.isInputValidInput, |
|
search: function (value, comparison) { |
|
return value.toLowerCase().endsWith(comparison[0].toLowerCase()); |
|
} |
|
}, |
|
'null': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.string.empty', i18n.conditions.string.empty); |
|
}, |
|
init: Criteria.initNoValue, |
|
inputValue: function () { return; }, |
|
isInputValid: function () { return true; }, |
|
search: function (value) { |
|
return (value === null || value === undefined || value.length === 0); |
|
} |
|
}, |
|
'!null': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.string.notEmpty', i18n.conditions.string.notEmpty); |
|
}, |
|
isInputValid: function () { return true; }, |
|
init: Criteria.initNoValue, |
|
inputValue: function () { |
|
return; |
|
}, |
|
search: function (value) { |
|
return !(value === null || value === undefined || value.length === 0); |
|
} |
|
} |
|
}; |
|
// The order of the conditions will make tslint sad :( |
|
Criteria.arrayConditions = { |
|
'contains': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.array.contains', i18n.conditions.array.contains); |
|
}, |
|
init: Criteria.initSelectArray, |
|
inputValue: Criteria.inputValueSelect, |
|
isInputValid: Criteria.isInputValidSelect, |
|
search: function (value, comparison) { |
|
return value.indexOf(comparison[0]) !== -1; |
|
} |
|
}, |
|
'without': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.array.without', i18n.conditions.array.without); |
|
}, |
|
init: Criteria.initSelectArray, |
|
inputValue: Criteria.inputValueSelect, |
|
isInputValid: Criteria.isInputValidSelect, |
|
search: function (value, comparison) { |
|
return value.indexOf(comparison[0]) === -1; |
|
} |
|
}, |
|
'=': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.array.equals', i18n.conditions.array.equals); |
|
}, |
|
init: Criteria.initSelect, |
|
inputValue: Criteria.inputValueSelect, |
|
isInputValid: Criteria.isInputValidSelect, |
|
search: function (value, comparison) { |
|
if (value.length === comparison[0].length) { |
|
for (var i = 0; i < value.length; i++) { |
|
if (value[i] !== comparison[0][i]) { |
|
return false; |
|
} |
|
} |
|
return true; |
|
} |
|
return false; |
|
} |
|
}, |
|
'!=': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.array.not', i18n.conditions.array.not); |
|
}, |
|
init: Criteria.initSelect, |
|
inputValue: Criteria.inputValueSelect, |
|
isInputValid: Criteria.isInputValidSelect, |
|
search: function (value, comparison) { |
|
if (value.length === comparison[0].length) { |
|
for (var i = 0; i < value.length; i++) { |
|
if (value[i] !== comparison[0][i]) { |
|
return true; |
|
} |
|
} |
|
return false; |
|
} |
|
return true; |
|
} |
|
}, |
|
'null': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.array.empty', i18n.conditions.array.empty); |
|
}, |
|
init: Criteria.initNoValue, |
|
isInputValid: function () { return true; }, |
|
inputValue: function () { return; }, |
|
search: function (value) { |
|
return (value === null || value === undefined || value.length === 0); |
|
} |
|
}, |
|
'!null': { |
|
conditionName: function (dt, i18n) { |
|
return dt.i18n('searchBuilder.conditions.array.notEmpty', i18n.conditions.array.notEmpty); |
|
}, |
|
isInputValid: function () { return true; }, |
|
init: Criteria.initNoValue, |
|
inputValue: function () { return; }, |
|
search: function (value) { |
|
return (value !== null && value !== undefined && value.length !== 0); |
|
} |
|
} |
|
}; |
|
Criteria.defaults = { |
|
columns: true, |
|
conditions: { |
|
'array': Criteria.arrayConditions, |
|
'date': Criteria.dateConditions, |
|
'html': Criteria.stringConditions, |
|
'html-num': Criteria.numConditions, |
|
'html-num-fmt': Criteria.numFmtConditions, |
|
'moment': Criteria.momentDateConditions, |
|
'num': Criteria.numConditions, |
|
'num-fmt': Criteria.numFmtConditions, |
|
'string': Criteria.stringConditions |
|
}, |
|
depthLimit: false, |
|
filterChanged: undefined, |
|
greyscale: false, |
|
i18n: { |
|
add: 'Add Condition', |
|
button: { |
|
0: 'Search Builder', |
|
_: 'Search Builder (%d)' |
|
}, |
|
clearAll: 'Clear All', |
|
condition: 'Condition', |
|
data: 'Data', |
|
deleteTitle: 'Delete filtering rule', |
|
leftTitle: 'Outdent criteria', |
|
logicAnd: 'And', |
|
logicOr: 'Or', |
|
rightTitle: 'Indent criteria', |
|
title: { |
|
0: 'Custom Search Builder', |
|
_: 'Custom Search Builder (%d)' |
|
}, |
|
value: 'Value', |
|
valueJoiner: 'and' |
|
}, |
|
logic: 'AND', |
|
orthogonal: { |
|
display: 'display', |
|
search: 'filter' |
|
}, |
|
preDefined: false |
|
}; |
|
return Criteria; |
|
}()); |
|
|
|
var $$1; |
|
var DataTable$1; |
|
/** |
|
* Sets the value of jQuery for use in the file |
|
* @param jq the instance of jQuery to be set |
|
*/ |
|
function setJQuery$1(jq) { |
|
$$1 = jq; |
|
DataTable$1 = jq.fn.dataTable; |
|
} |
|
/** |
|
* The Group class is used within SearchBuilder to represent a group of criteria |
|
*/ |
|
var Group = /** @class */ (function () { |
|
function Group(table, opts, topGroup, index, isChild, depth) { |
|
if (index === void 0) { index = 0; } |
|
if (isChild === void 0) { isChild = false; } |
|
if (depth === void 0) { depth = 1; } |
|
// Check that the required version of DataTables is included |
|
if (!DataTable$1 || !DataTable$1.versionCheck || !DataTable$1.versionCheck('1.10.0')) { |
|
throw new Error('SearchBuilder requires DataTables 1.10 or newer'); |
|
} |
|
this.classes = $$1.extend(true, {}, Group.classes); |
|
// Get options from user |
|
this.c = $$1.extend(true, {}, Group.defaults, opts); |
|
this.s = { |
|
criteria: [], |
|
depth: depth, |
|
dt: table, |
|
index: index, |
|
isChild: isChild, |
|
logic: undefined, |
|
opts: opts, |
|
toDrop: undefined, |
|
topGroup: topGroup |
|
}; |
|
this.dom = { |
|
add: $$1('<button/>') |
|
.addClass(this.classes.add) |
|
.addClass(this.classes.button) |
|
.attr('type', 'button'), |
|
clear: $$1('<button>×</button>') |
|
.addClass(this.classes.button) |
|
.addClass(this.classes.clearGroup) |
|
.attr('type', 'button'), |
|
container: $$1('<div/>') |
|
.addClass(this.classes.group), |
|
logic: $$1('<button/>') |
|
.addClass(this.classes.logic) |
|
.addClass(this.classes.button) |
|
.attr('type', 'button'), |
|
logicContainer: $$1('<div/>') |
|
.addClass(this.classes.logicContainer) |
|
}; |
|
// A reference to the top level group is maintained throughout any subgroups and criteria that may be created |
|
if (this.s.topGroup === undefined) { |
|
this.s.topGroup = this.dom.container; |
|
} |
|
this._setup(); |
|
return this; |
|
} |
|
/** |
|
* Destroys the groups buttons, clears the internal criteria and removes it from the dom |
|
*/ |
|
Group.prototype.destroy = function () { |
|
// Turn off listeners |
|
$$1(this.dom.add).off('.dtsb'); |
|
$$1(this.dom.logic).off('.dtsb'); |
|
// Trigger event for groups at a higher level to pick up on |
|
$$1(this.dom.container) |
|
.trigger('dtsb-destroy') |
|
.remove(); |
|
this.s.criteria = []; |
|
}; |
|
/** |
|
* Gets the details required to rebuild the group |
|
*/ |
|
Group.prototype.getDetails = function () { |
|
if (this.s.criteria.length === 0) { |
|
return {}; |
|
} |
|
var details = { |
|
criteria: [], |
|
logic: this.s.logic |
|
}; |
|
// NOTE here crit could be either a subgroup or a criteria |
|
for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) { |
|
var crit = _a[_i]; |
|
details.criteria.push(crit.criteria.getDetails()); |
|
} |
|
return details; |
|
}; |
|
/** |
|
* Getter for the node for the container of the group |
|
* @returns Node for the container of the group |
|
*/ |
|
Group.prototype.getNode = function () { |
|
return this.dom.container; |
|
}; |
|
/** |
|
* Rebuilds the group based upon the details passed in |
|
* @param loadedDetails the details required to rebuild the group |
|
*/ |
|
Group.prototype.rebuild = function (loadedDetails) { |
|
// If no criteria are stored then just return |
|
if (loadedDetails.criteria === undefined || loadedDetails.criteria === null || loadedDetails.criteria.length === 0) { |
|
return; |
|
} |
|
this.s.logic = loadedDetails.logic; |
|
$$1(this.dom.logic).text(this.s.logic === 'OR' |
|
? this.s.dt.i18n('searchBuilder.logicOr', this.c.i18n.logicOr) |
|
: this.s.dt.i18n('searchBuilder.logicAnd', this.c.i18n.logicAnd)); |
|
// Add all of the criteria, be it a sub group or a criteria |
|
for (var _i = 0, _a = loadedDetails.criteria; _i < _a.length; _i++) { |
|
var crit = _a[_i]; |
|
if (crit.logic !== undefined) { |
|
this._addPrevGroup(crit); |
|
} |
|
else if (crit.logic === undefined) { |
|
this._addPrevCriteria(crit); |
|
} |
|
} |
|
// For all of the criteria children, update the arrows incase they require changing and set the listeners |
|
for (var _b = 0, _c = this.s.criteria; _b < _c.length; _b++) { |
|
var crit = _c[_b]; |
|
if (crit.criteria instanceof Criteria) { |
|
crit.criteria.updateArrows(this.s.criteria.length > 1, false); |
|
this._setCriteriaListeners(crit.criteria); |
|
} |
|
} |
|
}; |
|
/** |
|
* Redraws the Contents of the searchBuilder Groups and Criteria |
|
*/ |
|
Group.prototype.redrawContents = function () { |
|
// Clear the container out and add the basic elements |
|
$$1(this.dom.container) |
|
.empty() |
|
.append(this.dom.logicContainer) |
|
.append(this.dom.add); |
|
// Sort the criteria by index so that they appear in the correct order |
|
this.s.criteria.sort(function (a, b) { |
|
if (a.criteria.s.index < b.criteria.s.index) { |
|
return -1; |
|
} |
|
else if (a.criteria.s.index > b.criteria.s.index) { |
|
return 1; |
|
} |
|
return 0; |
|
}); |
|
this.setListeners(); |
|
for (var i = 0; i < this.s.criteria.length; i++) { |
|
var crit = this.s.criteria[i].criteria; |
|
if (crit instanceof Criteria) { |
|
// Reset the index to the new value |
|
this.s.criteria[i].index = i; |
|
this.s.criteria[i].criteria.s.index = i; |
|
// Add to the group |
|
$$1(this.s.criteria[i].criteria.dom.container).insertBefore(this.dom.add); |
|
// Set listeners for various points |
|
this._setCriteriaListeners(crit); |
|
this.s.criteria[i].criteria.rebuild(this.s.criteria[i].criteria.getDetails()); |
|
} |
|
else if (crit instanceof Group && crit.s.criteria.length > 0) { |
|
// Reset the index to the new value |
|
this.s.criteria[i].index = i; |
|
this.s.criteria[i].criteria.s.index = i; |
|
// Add the sub group to the group |
|
$$1(this.s.criteria[i].criteria.dom.container).insertBefore(this.dom.add); |
|
// Redraw the contents of the group |
|
crit.redrawContents(); |
|
this._setGroupListeners(crit); |
|
} |
|
else { |
|
// The group is empty so remove it |
|
this.s.criteria.splice(i, 1); |
|
i--; |
|
} |
|
} |
|
this.setupLogic(); |
|
}; |
|
/** |
|
* Search method, checking the row data against the criteria in the group |
|
* @param rowData The row data to be compared |
|
* @returns boolean The result of the search |
|
*/ |
|
Group.prototype.search = function (rowData, rowIdx) { |
|
if (this.s.logic === 'AND') { |
|
return this._andSearch(rowData, rowIdx); |
|
} |
|
else if (this.s.logic === 'OR') { |
|
return this._orSearch(rowData, rowIdx); |
|
} |
|
return true; |
|
}; |
|
/** |
|
* Locates the groups logic button to the correct location on the page |
|
*/ |
|
Group.prototype.setupLogic = function () { |
|
// Remove logic button |
|
$$1(this.dom.logicContainer).remove(); |
|
$$1(this.dom.clear).remove(); |
|
// If there are no criteria in the group then keep the logic removed and return |
|
if (this.s.criteria.length < 1) { |
|
if (!this.s.isChild) { |
|
$$1(this.dom.container).trigger('dtsb-destroy'); |
|
// Set criteria left margin |
|
$$1(this.dom.container).css('margin-left', 0); |
|
} |
|
return; |
|
} |
|
// Set width, take 2 for the border |
|
var height = $$1(this.dom.container).height() - 2; |
|
$$1(this.dom.clear).height('0px'); |
|
$$1(this.dom.logicContainer).append(this.dom.clear).width(height); |
|
// Prepend logic button |
|
$$1(this.dom.container).prepend(this.dom.logicContainer); |
|
this._setLogicListener(); |
|
// Set criteria left margin |
|
$$1(this.dom.container).css('margin-left', $$1(this.dom.logicContainer).outerHeight(true)); |
|
var logicOffset = $$1(this.dom.logicContainer).offset(); |
|
// Set horizontal alignment |
|
var currentLeft = logicOffset.left; |
|
var groupLeft = $$1(this.dom.container).offset().left; |
|
var shuffleLeft = currentLeft - groupLeft; |
|
var newPos = currentLeft - shuffleLeft - $$1(this.dom.logicContainer).outerHeight(true); |
|
$$1(this.dom.logicContainer).offset({ left: newPos }); |
|
// Set vertical alignment |
|
var firstCrit = $$1(this.dom.logicContainer).next(); |
|
var currentTop = logicOffset.top; |
|
var firstTop = $$1(firstCrit).offset().top; |
|
var shuffleTop = currentTop - firstTop; |
|
var newTop = currentTop - shuffleTop; |
|
$$1(this.dom.logicContainer).offset({ top: newTop }); |
|
$$1(this.dom.clear).outerHeight($$1(this.dom.logicContainer).height()); |
|
this._setClearListener(); |
|
}; |
|
/** |
|
* Sets listeners on the groups elements |
|
*/ |
|
Group.prototype.setListeners = function () { |
|
var _this = this; |
|
$$1(this.dom.add).unbind('click'); |
|
$$1(this.dom.add).on('click', function () { |
|
// If this is the parent group then the logic button has not been added yet |
|
if (!_this.s.isChild) { |
|
$$1(_this.dom.container).prepend(_this.dom.logicContainer); |
|
} |
|
_this.addCriteria(); |
|
$$1(_this.dom.container).trigger('dtsb-add'); |
|
_this.s.dt.state.save(); |
|
return false; |
|
}); |
|
for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) { |
|
var crit = _a[_i]; |
|
crit.criteria.setListeners(); |
|
} |
|
this._setClearListener(); |
|
this._setLogicListener(); |
|
}; |
|
/** |
|
* Adds a criteria to the group |
|
* @param crit Instance of Criteria to be added to the group |
|
*/ |
|
Group.prototype.addCriteria = function (crit, redraw) { |
|
if (crit === void 0) { crit = null; } |
|
if (redraw === void 0) { redraw = true; } |
|
var index = crit === null ? this.s.criteria.length : crit.s.index; |
|
var criteria = new Criteria(this.s.dt, this.s.opts, this.s.topGroup, index, this.s.depth); |
|
// If a Criteria has been passed in then set the values to continue that |
|
if (crit !== null) { |
|
criteria.c = crit.c; |
|
criteria.s = crit.s; |
|
criteria.s.depth = this.s.depth; |
|
criteria.classes = crit.classes; |
|
} |
|
criteria.populate(); |
|
var inserted = false; |
|
for (var i = 0; i < this.s.criteria.length; i++) { |
|
if (i === 0 && this.s.criteria[i].criteria.s.index > criteria.s.index) { |
|
// Add the node for the criteria at the start of the group |
|
$$1(criteria.getNode()).insertBefore(this.s.criteria[i].criteria.dom.container); |
|
inserted = true; |
|
} |
|
else if (i < this.s.criteria.length - 1 && |
|
this.s.criteria[i].criteria.s.index < criteria.s.index && |
|
this.s.criteria[i + 1].criteria.s.index > criteria.s.index) { |
|
// Add the node for the criteria in the correct location |
|
$$1(criteria.getNode()).insertAfter(this.s.criteria[i].criteria.dom.container); |
|
inserted = true; |
|
} |
|
} |
|
if (!inserted) { |
|
$$1(criteria.getNode()).insertBefore(this.dom.add); |
|
} |
|
// Add the details for this criteria to the array |
|
this.s.criteria.push({ |
|
criteria: criteria, |
|
index: index |
|
}); |
|
this.s.criteria = this.s.criteria.sort(function (a, b) { |
|
return a.criteria.s.index - b.criteria.s.index; |
|
}); |
|
for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) { |
|
var opt = _a[_i]; |
|
if (opt.criteria instanceof Criteria) { |
|
opt.criteria.updateArrows(this.s.criteria.length > 1, redraw); |
|
} |
|
} |
|
this._setCriteriaListeners(criteria); |
|
criteria.setListeners(); |
|
this.setupLogic(); |
|
}; |
|
/** |
|
* Checks the group to see if it has any filled criteria |
|
*/ |
|
Group.prototype.checkFilled = function () { |
|
for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) { |
|
var crit = _a[_i]; |
|
if ((crit.criteria instanceof Criteria && crit.criteria.s.filled) || |
|
(crit.criteria instanceof Group && crit.criteria.checkFilled())) { |
|
return true; |
|
} |
|
} |
|
return false; |
|
}; |
|
/** |
|
* Gets the count for the number of criteria in this group and any sub groups |
|
*/ |
|
Group.prototype.count = function () { |
|
var count = 0; |
|
for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) { |
|
var crit = _a[_i]; |
|
if (crit.criteria instanceof Group) { |
|
count += crit.criteria.count(); |
|
} |
|
else { |
|
count++; |
|
} |
|
} |
|
return count; |
|
}; |
|
/** |
|
* Rebuilds a sub group that previously existed |
|
* @param loadedGroup The details of a group within this group |
|
*/ |
|
Group.prototype._addPrevGroup = function (loadedGroup) { |
|
var idx = this.s.criteria.length; |
|
var group = new Group(this.s.dt, this.c, this.s.topGroup, idx, true, this.s.depth + 1); |
|
// Add the new group to the criteria array |
|
this.s.criteria.push({ |
|
criteria: group, |
|
index: idx, |
|
logic: group.s.logic |
|
}); |
|
// Rebuild it with the previous conditions for that group |
|
group.rebuild(loadedGroup); |
|
this.s.criteria[idx].criteria = group; |
|
$$1(this.s.topGroup).trigger('dtsb-redrawContents'); |
|
this._setGroupListeners(group); |
|
}; |
|
/** |
|
* Rebuilds a criteria of this group that previously existed |
|
* @param loadedCriteria The details of a criteria within the group |
|
*/ |
|
Group.prototype._addPrevCriteria = function (loadedCriteria) { |
|
var idx = this.s.criteria.length; |
|
var criteria = new Criteria(this.s.dt, this.s.opts, this.s.topGroup, idx, this.s.depth); |
|
criteria.populate(); |
|
// Add the new criteria to the criteria array |
|
this.s.criteria.push({ |
|
criteria: criteria, |
|
index: idx |
|
}); |
|
// Rebuild it with the previous conditions for that criteria |
|
criteria.rebuild(loadedCriteria); |
|
this.s.criteria[idx].criteria = criteria; |
|
$$1(this.s.topGroup).trigger('dtsb-redrawContents'); |
|
}; |
|
/** |
|
* Checks And the criteria using AND logic |
|
* @param rowData The row data to be checked against the search criteria |
|
* @returns boolean The result of the AND search |
|
*/ |
|
Group.prototype._andSearch = function (rowData, rowIdx) { |
|
// If there are no criteria then return true for this group |
|
if (this.s.criteria.length === 0) { |
|
return true; |
|
} |
|
for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) { |
|
var crit = _a[_i]; |
|
// If the criteria is not complete then skip it |
|
if (crit.criteria instanceof Criteria && !crit.criteria.s.filled) { |
|
continue; |
|
} |
|
// Otherwise if a single one fails return false |
|
else if (!crit.criteria.search(rowData, rowIdx)) { |
|
return false; |
|
} |
|
} |
|
// If we get to here then everything has passed, so return true for the group |
|
return true; |
|
}; |
|
/** |
|
* Checks And the criteria using OR logic |
|
* @param rowData The row data to be checked against the search criteria |
|
* @returns boolean The result of the OR search |
|
*/ |
|
Group.prototype._orSearch = function (rowData, rowIdx) { |
|
// If there are no criteria in the group then return true |
|
if (this.s.criteria.length === 0) { |
|
return true; |
|
} |
|
// This will check to make sure that at least one criteria in the group is complete |
|
var filledfound = false; |
|
for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) { |
|
var crit = _a[_i]; |
|
if (crit.criteria instanceof Criteria && crit.criteria.s.filled) { |
|
// A completed criteria has been found so set the flag |
|
filledfound = true; |
|
// If the search passes then return true |
|
if (crit.criteria.search(rowData, rowIdx)) { |
|
return true; |
|
} |
|
} |
|
else if (crit.criteria instanceof Group && crit.criteria.checkFilled()) { |
|
filledfound = true; |
|
if (crit.criteria.search(rowData, rowIdx)) { |
|
return true; |
|
} |
|
} |
|
} |
|
// If we get here we need to return the inverse of filledfound, |
|
// as if any have been found and we are here then none have passed |
|
return !filledfound; |
|
}; |
|
/** |
|
* Removes a criteria from the group |
|
* @param criteria The criteria instance to be removed |
|
*/ |
|
Group.prototype._removeCriteria = function (criteria, group) { |
|
if (group === void 0) { group = false; } |
|
// If removing a criteria and there is only then then just destroy the group |
|
if (this.s.criteria.length <= 1 && this.s.isChild) { |
|
this.destroy(); |
|
} |
|
else { |
|
// Otherwise splice the given criteria out and redo the indexes |
|
var last = void 0; |
|
for (var i = 0; i < this.s.criteria.length; i++) { |
|
if (this.s.criteria[i].index === criteria.s.index && (!group || this.s.criteria[i].criteria instanceof Group)) { |
|
last = i; |
|
} |
|
} |
|
// We want to remove the last element with the desired index, as its replacement will be inserted before it |
|
if (last !== undefined) { |
|
this.s.criteria.splice(last, 1); |
|
} |
|
for (var i = 0; i < this.s.criteria.length; i++) { |
|
this.s.criteria[i].index = i; |
|
this.s.criteria[i].criteria.s.index = i; |
|
} |
|
} |
|
}; |
|
/** |
|
* Sets the listeners in group for a criteria |
|
* @param criteria The criteria for the listeners to be set on |
|
*/ |
|
Group.prototype._setCriteriaListeners = function (criteria) { |
|
var _this = this; |
|
$$1(criteria.dom["delete"]) |
|
.unbind('click') |
|
.on('click', function () { |
|
_this._removeCriteria(criteria); |
|
$$1(criteria.dom.container).remove(); |
|
for (var _i = 0, _a = _this.s.criteria; _i < _a.length; _i++) { |
|
var crit = _a[_i]; |
|
if (crit.criteria instanceof Criteria) { |
|
crit.criteria.updateArrows(_this.s.criteria.length > 1); |
|
} |
|
} |
|
criteria.destroy(); |
|
_this.s.dt.draw(); |
|
$$1(_this.s.topGroup).trigger('dtsb-redrawContents'); |
|
$$1(_this.s.topGroup).trigger('dtsb-updateTitle'); |
|
return false; |
|
}); |
|
$$1(criteria.dom.right) |
|
.unbind('click') |
|
.on('click', function () { |
|
var idx = criteria.s.index; |
|
var group = new Group(_this.s.dt, _this.s.opts, _this.s.topGroup, criteria.s.index, true, _this.s.depth + 1); |
|
// Add the criteria that is to be moved to the new group |
|
group.addCriteria(criteria); |
|
// Update the details in the current groups criteria array |
|
_this.s.criteria[idx].criteria = group; |
|
_this.s.criteria[idx].logic = 'AND'; |
|
$$1(_this.s.topGroup).trigger('dtsb-redrawContents'); |
|
_this._setGroupListeners(group); |
|
return false; |
|
}); |
|
$$1(criteria.dom.left) |
|
.unbind('click') |
|
.on('click', function () { |
|
_this.s.toDrop = new Criteria(_this.s.dt, _this.s.opts, _this.s.topGroup, criteria.s.index); |
|
_this.s.toDrop.s = criteria.s; |
|
_this.s.toDrop.c = criteria.c; |
|
_this.s.toDrop.classes = criteria.classes; |
|
_this.s.toDrop.populate(); |
|
// The dropCriteria event mutates the reference to the index so need to store it |
|
var index = _this.s.toDrop.s.index; |
|
$$1(_this.dom.container).trigger('dtsb-dropCriteria'); |
|
criteria.s.index = index; |
|
_this._removeCriteria(criteria); |
|
// By tracking the top level group we can directly trigger a redraw on it, |
|
// bubbling is also possible, but that is slow with deep levelled groups |
|
$$1(_this.s.topGroup).trigger('dtsb-redrawContents'); |
|
_this.s.dt.draw(); |
|
return false; |
|
}); |
|
}; |
|
/** |
|
* Set's the listeners for the group clear button |
|
*/ |
|
Group.prototype._setClearListener = function () { |
|
var _this = this; |
|
$$1(this.dom.clear) |
|
.unbind('click') |
|
.on('click', function () { |
|
if (!_this.s.isChild) { |
|
$$1(_this.dom.container).trigger('dtsb-clearContents'); |
|
return false; |
|
} |
|
_this.destroy(); |
|
$$1(_this.s.topGroup).trigger('dtsb-updateTitle'); |
|
$$1(_this.s.topGroup).trigger('dtsb-redrawContents'); |
|
return false; |
|
}); |
|
}; |
|
/** |
|
* Sets listeners for sub groups of this group |
|
* @param group The sub group that the listeners are to be set on |
|
*/ |
|
Group.prototype._setGroupListeners = function (group) { |
|
var _this = this; |
|
// Set listeners for the new group |
|
$$1(group.dom.add) |
|
.unbind('click') |
|
.on('click', function () { |
|
_this.setupLogic(); |
|
$$1(_this.dom.container).trigger('dtsb-add'); |
|
return false; |
|
}); |
|
$$1(group.dom.container) |
|
.unbind('dtsb-add') |
|
.on('dtsb-add', function () { |
|
_this.setupLogic(); |
|
$$1(_this.dom.container).trigger('dtsb-add'); |
|
return false; |
|
}); |
|
$$1(group.dom.container) |
|
.unbind('dtsb-destroy') |
|
.on('dtsb-destroy', function () { |
|
_this._removeCriteria(group, true); |
|
$$1(group.dom.container).remove(); |
|
_this.setupLogic(); |
|
return false; |
|
}); |
|
$$1(group.dom.container) |
|
.unbind('dtsb-dropCriteria') |
|
.on('dtsb-dropCriteria', function () { |
|
var toDrop = group.s.toDrop; |
|
toDrop.s.index = group.s.index; |
|
toDrop.updateArrows(_this.s.criteria.length > 1, false); |
|
_this.addCriteria(toDrop, false); |
|
return false; |
|
}); |
|
group.setListeners(); |
|
}; |
|
/** |
|
* Sets up the Group instance, setting listeners and appending elements |
|
*/ |
|
Group.prototype._setup = function () { |
|
this.setListeners(); |
|
$$1(this.dom.add).text(this.s.dt.i18n('searchBuilder.add', this.c.i18n.add)); |
|
$$1(this.dom.logic).text(this.c.logic === 'OR' |
|
? this.s.dt.i18n('searchBuilder.logicOr', this.c.i18n.logicOr) |
|
: this.s.dt.i18n('searchBuilder.logicAnd', this.c.i18n.logicAnd)); |
|
this.s.logic = this.c.logic === 'OR' ? 'OR' : 'AND'; |
|
if (this.c.greyscale) { |
|
$$1(this.dom.logic).addClass(this.classes.greyscale); |
|
} |
|
$$1(this.dom.logicContainer).append(this.dom.logic).append(this.dom.clear); |
|
// Only append the logic button immediately if this is a sub group, |
|
// otherwise it will be prepended later when adding a criteria |
|
if (this.s.isChild) { |
|
$$1(this.dom.container).append(this.dom.logicContainer); |
|
} |
|
$$1(this.dom.container).append(this.dom.add); |
|
}; |
|
/** |
|
* Sets the listener for the logic button |
|
*/ |
|
Group.prototype._setLogicListener = function () { |
|
var _this = this; |
|
$$1(this.dom.logic) |
|
.unbind('click') |
|
.on('click', function () { |
|
_this._toggleLogic(); |
|
_this.s.dt.draw(); |
|
for (var _i = 0, _a = _this.s.criteria; _i < _a.length; _i++) { |
|
var crit = _a[_i]; |
|
crit.criteria.setListeners(); |
|
} |
|
}); |
|
}; |
|
/** |
|
* Toggles the logic for the group |
|
*/ |
|
Group.prototype._toggleLogic = function () { |
|
if (this.s.logic === 'OR') { |
|
this.s.logic = 'AND'; |
|
$$1(this.dom.logic).text(this.s.dt.i18n('searchBuilder.logicAnd', this.c.i18n.logicAnd)); |
|
} |
|
else if (this.s.logic === 'AND') { |
|
this.s.logic = 'OR'; |
|
$$1(this.dom.logic).text(this.s.dt.i18n('searchBuilder.logicOr', this.c.i18n.logicOr)); |
|
} |
|
}; |
|
Group.version = '1.0.0'; |
|
Group.classes = { |
|
add: 'dtsb-add', |
|
button: 'dtsb-button', |
|
clearGroup: 'dtsb-clearGroup', |
|
greyscale: 'dtsb-greyscale', |
|
group: 'dtsb-group', |
|
inputButton: 'dtsb-iptbtn', |
|
logic: 'dtsb-logic', |
|
logicContainer: 'dtsb-logicContainer' |
|
}; |
|
Group.defaults = { |
|
columns: true, |
|
conditions: { |
|
'date': Criteria.dateConditions, |
|
'html': Criteria.stringConditions, |
|
'html-num': Criteria.numConditions, |
|
'html-num-fmt': Criteria.numFmtConditions, |
|
'moment': Criteria.momentDateConditions, |
|
'num': Criteria.numConditions, |
|
'num-fmt': Criteria.numFmtConditions, |
|
'string': Criteria.stringConditions |
|
}, |
|
depthLimit: false, |
|
filterChanged: undefined, |
|
greyscale: false, |
|
i18n: { |
|
add: 'Add Condition', |
|
button: { |
|
0: 'Search Builder', |
|
_: 'Search Builder (%d)' |
|
}, |
|
clearAll: 'Clear All', |
|
condition: 'Condition', |
|
data: 'Data', |
|
deleteTitle: 'Delete filtering rule', |
|
leftTitle: 'Outdent criteria', |
|
logicAnd: 'And', |
|
logicOr: 'Or', |
|
rightTitle: 'Indent criteria', |
|
title: { |
|
0: 'Custom Search Builder', |
|
_: 'Custom Search Builder (%d)' |
|
}, |
|
value: 'Value', |
|
valueJoiner: 'and' |
|
}, |
|
logic: 'AND', |
|
orthogonal: { |
|
display: 'display', |
|
search: 'filter' |
|
}, |
|
preDefined: false |
|
}; |
|
return Group; |
|
}()); |
|
|
|
var $$2; |
|
var DataTable$2; |
|
/** |
|
* Sets the value of jQuery for use in the file |
|
* @param jq the instance of jQuery to be set |
|
*/ |
|
function setJQuery$2(jq) { |
|
$$2 = jq; |
|
DataTable$2 = jq.fn.DataTable; |
|
} |
|
/** |
|
* SearchBuilder class for DataTables. |
|
* Allows for complex search queries to be constructed and implemented on a DataTable |
|
*/ |
|
var SearchBuilder = /** @class */ (function () { |
|
function SearchBuilder(builderSettings, opts) { |
|
var _this = this; |
|
// Check that the required version of DataTables is included |
|
if (!DataTable$2 || !DataTable$2.versionCheck || !DataTable$2.versionCheck('1.10.0')) { |
|
throw new Error('SearchBuilder requires DataTables 1.10 or newer'); |
|
} |
|
var table = new DataTable$2.Api(builderSettings); |
|
this.classes = $$2.extend(true, {}, SearchBuilder.classes); |
|
// Get options from user |
|
this.c = $$2.extend(true, {}, SearchBuilder.defaults, opts); |
|
this.dom = { |
|
clearAll: $$2('<button type="button">' + table.i18n('searchBuilder.clearAll', this.c.i18n.clearAll) + '</button>') |
|
.addClass(this.classes.clearAll) |
|
.addClass(this.classes.button) |
|
.attr('type', 'button'), |
|
container: $$2('<div/>') |
|
.addClass(this.classes.container), |
|
title: $$2('<div/>') |
|
.addClass(this.classes.title), |
|
titleRow: $$2('<div/>') |
|
.addClass(this.classes.titleRow), |
|
topGroup: undefined |
|
}; |
|
this.s = { |
|
dt: table, |
|
opts: opts, |
|
search: undefined, |
|
topGroup: undefined |
|
}; |
|
// If searchbuilder is already defined for this table then return |
|
if (table.settings()[0]._searchBuilder !== undefined) { |
|
return; |
|
} |
|
table.settings()[0]._searchBuilder = this; |
|
// Run the remaining setup when the table is initialised |
|
if (this.s.dt.settings()[0]._bInitComplete) { |
|
this._setUp(); |
|
} |
|
else { |
|
table.one('init.dt', function () { |
|
_this._setUp(); |
|
}); |
|
} |
|
return this; |
|
} |
|
/** |
|
* Gets the details required to rebuild the SearchBuilder as it currently is |
|
*/ |
|
SearchBuilder.prototype.getDetails = function () { |
|
return this.s.topGroup.getDetails(); |
|
}; |
|
/** |
|
* Getter for the node of the container for the searchBuilder |
|
* @returns JQuery<HTMLElement> the node of the container |
|
*/ |
|
SearchBuilder.prototype.getNode = function () { |
|
return this.dom.container; |
|
}; |
|
/** |
|
* Rebuilds the SearchBuilder to a state that is provided |
|
* @param details The details required to perform a rebuild |
|
*/ |
|
SearchBuilder.prototype.rebuild = function (details) { |
|
$$2(this.dom.clearAll).click(); |
|
// If there are no details to rebuild then return |
|
if (details === undefined || details === null) { |
|
return this; |
|
} |
|
this.s.topGroup.rebuild(details); |
|
this.s.dt.draw(); |
|
this.s.topGroup.setListeners(); |
|
return this; |
|
}; |
|
/** |
|
* Applies the defaults to preDefined criteria |
|
* @param preDef the array of criteria to be processed. |
|
*/ |
|
SearchBuilder.prototype._applyPreDefDefaults = function (preDef) { |
|
var _this = this; |
|
if (preDef.criteria !== undefined && preDef.logic === undefined) { |
|
preDef.logic = 'AND'; |
|
} |
|
var _loop_1 = function (crit) { |
|
// Apply the defaults to any further criteria |
|
if (crit.criteria !== undefined) { |
|
crit = this_1._applyPreDefDefaults(crit); |
|
} |
|
else { |
|
this_1.s.dt.columns().every(function (index) { |
|
if (_this.s.dt.settings()[0].aoColumns[index].sTitle === crit.data) { |
|
crit.dataIdx = index; |
|
} |
|
}); |
|
} |
|
}; |
|
var this_1 = this; |
|
for (var _i = 0, _a = preDef.criteria; _i < _a.length; _i++) { |
|
var crit = _a[_i]; |
|
_loop_1(crit); |
|
} |
|
return preDef; |
|
}; |
|
/** |
|
* Set's up the SearchBuilder |
|
*/ |
|
SearchBuilder.prototype._setUp = function (loadState) { |
|
var _this = this; |
|
if (loadState === void 0) { loadState = true; } |
|
this.s.topGroup = new Group(this.s.dt, this.c, undefined); |
|
this._setClearListener(); |
|
this.s.dt.on('stateSaveParams', function (e, settings, data) { |
|
data.searchBuilder = _this.getDetails(); |
|
data.page = _this.s.dt.page(); |
|
}); |
|
this._build(); |
|
if (loadState) { |
|
var loadedState = this.s.dt.state.loaded(); |
|
// If the loaded State is not null rebuild based on it for statesave |
|
if (loadedState !== null && loadedState.searchBuilder !== undefined) { |
|
this.s.topGroup.rebuild(loadedState.searchBuilder); |
|
$$2(this.s.topGroup.dom.container).trigger('dtsb-redrawContents'); |
|
this.s.dt.page(loadedState.page).draw('page'); |
|
this.s.topGroup.setListeners(); |
|
} |
|
// Otherwise load any predefined options |
|
else if (this.c.preDefined !== false) { |
|
this.c.preDefined = this._applyPreDefDefaults(this.c.preDefined); |
|
this.rebuild(this.c.preDefined); |
|
} |
|
} |
|
this._setEmptyListener(); |
|
this.s.dt.state.save(); |
|
}; |
|
/** |
|
* Updates the title of the SearchBuilder |
|
* @param count the number of filters in the SearchBuilder |
|
*/ |
|
SearchBuilder.prototype._updateTitle = function (count) { |
|
$$2(this.dom.title).text(this.s.dt.i18n('searchBuilder.title', this.c.i18n.title, count)); |
|
}; |
|
/** |
|
* Builds all of the dom elements together |
|
*/ |
|
SearchBuilder.prototype._build = function () { |
|
var _this = this; |
|
// Empty and setup the container |
|
$$2(this.dom.clearAll).remove(); |
|
$$2(this.dom.container).empty(); |
|
var count = this.s.topGroup.count(); |
|
this._updateTitle(count); |
|
$$2(this.dom.titleRow).append(this.dom.title); |
|
$$2(this.dom.container).append(this.dom.titleRow); |
|
this.dom.topGroup = this.s.topGroup.getNode(); |
|
$$2(this.dom.container).append(this.dom.topGroup); |
|
this._setRedrawListener(); |
|
var tableNode = this.s.dt.table(0).node(); |
|
if ($$2.fn.dataTable.ext.search.indexOf(this.s.search) === -1) { |
|
// Custom search function for SearchBuilder |
|
this.s.search = function (settings, searchData, dataIndex, origData) { |
|
if (settings.nTable !== tableNode) { |
|
return true; |
|
} |
|
return _this.s.topGroup.search(searchData, dataIndex); |
|
}; |
|
// Add SearchBuilder search function to the dataTables search array |
|
$$2.fn.dataTable.ext.search.push(this.s.search); |
|
} |
|
// Register an Api method for getting the column type |
|
$$2.fn.DataTable.Api.registerPlural('columns().type()', 'column().type()', function (selector, opts) { |
|
return this.iterator('column', function (settings, column) { |
|
return settings.aoColumns[column].sType; |
|
}, 1); |
|
}); |
|
this.s.dt.on('destroy.dt', function () { |
|
$$2(_this.dom.container).remove(); |
|
$$2(_this.dom.clearAll).remove(); |
|
var searchIdx = $$2.fn.dataTable.ext.search.indexOf(_this.s.search); |
|
while (searchIdx !== -1) { |
|
$$2.fn.dataTable.ext.search.splice(searchIdx, 1); |
|
searchIdx = $$2.fn.dataTable.ext.search.indexOf(_this.s.search); |
|
} |
|
}); |
|
}; |
|
/** |
|
* Checks if the clearAll button should be added or not |
|
*/ |
|
SearchBuilder.prototype._checkClear = function () { |
|
if (this.s.topGroup.s.criteria.length > 0) { |
|
$$2(this.dom.clearAll).insertAfter(this.dom.title); |
|
this._setClearListener(); |
|
} |
|
else { |
|
$$2(this.dom.clearAll).remove(); |
|
} |
|
}; |
|
/** |
|
* Update the count in the title/button |
|
* @param count Number of filters applied |
|
*/ |
|
SearchBuilder.prototype._filterChanged = function (count) { |
|
var fn = this.c.filterChanged; |
|
if (typeof fn === 'function') { |
|
fn(count, this.s.dt.i18n('searchBuilder.button', this.c.i18n.button, count)); |
|
} |
|
}; |
|
/** |
|
* Set the listener for the clear button |
|
*/ |
|
SearchBuilder.prototype._setClearListener = function () { |
|
var _this = this; |
|
$$2(this.dom.clearAll).unbind('click'); |
|
$$2(this.dom.clearAll).on('click', function () { |
|
_this.s.topGroup = new Group(_this.s.dt, _this.c, undefined); |
|
_this._build(); |
|
_this.s.dt.draw(); |
|
_this.s.topGroup.setListeners(); |
|
$$2(_this.dom.clearAll).remove(); |
|
_this._setEmptyListener(); |
|
_this._filterChanged(0); |
|
return false; |
|
}); |
|
}; |
|
/** |
|
* Set the listener for the Redraw event |
|
*/ |
|
SearchBuilder.prototype._setRedrawListener = function () { |
|
var _this = this; |
|
$$2(this.s.topGroup.dom.container).unbind('dtsb-redrawContents'); |
|
$$2(this.s.topGroup.dom.container).on('dtsb-redrawContents', function () { |
|
_this._checkClear(); |
|
_this.s.topGroup.redrawContents(); |
|
_this.s.topGroup.setupLogic(); |
|
_this._setEmptyListener(); |
|
var count = _this.s.topGroup.count(); |
|
_this._updateTitle(count); |
|
_this._filterChanged(count); |
|
_this.s.dt.state.save(); |
|
}); |
|
$$2(this.s.topGroup.dom.container).unbind('dtsb-clearContents'); |
|
$$2(this.s.topGroup.dom.container).on('dtsb-clearContents', function () { |
|
_this._setUp(false); |
|
_this._filterChanged(0); |
|
_this.s.dt.draw(); |
|
}); |
|
$$2(this.s.topGroup.dom.container).on('dtsb-updateTitle', function () { |
|
var count = _this.s.topGroup.count(); |
|
_this._updateTitle(count); |
|
_this._filterChanged(count); |
|
}); |
|
}; |
|
/** |
|
* Sets listeners to check whether clearAll should be added or removed |
|
*/ |
|
SearchBuilder.prototype._setEmptyListener = function () { |
|
var _this = this; |
|
$$2(this.s.topGroup.dom.add).on('click', function () { |
|
_this._checkClear(); |
|
}); |
|
$$2(this.s.topGroup.dom.container).on('dtsb-destroy', function () { |
|
$$2(_this.dom.clearAll).remove(); |
|
}); |
|
}; |
|
SearchBuilder.version = '1.0.1'; |
|
SearchBuilder.classes = { |
|
button: 'dtsb-button', |
|
clearAll: 'dtsb-clearAll', |
|
container: 'dtsb-searchBuilder', |
|
inputButton: 'dtsb-iptbtn', |
|
title: 'dtsb-title', |
|
titleRow: 'dtsb-titleRow' |
|
}; |
|
SearchBuilder.defaults = { |
|
columns: true, |
|
conditions: { |
|
'date': Criteria.dateConditions, |
|
'html': Criteria.stringConditions, |
|
'html-num': Criteria.numConditions, |
|
'html-num-fmt': Criteria.numFmtConditions, |
|
'moment': Criteria.momentDateConditions, |
|
'num': Criteria.numConditions, |
|
'num-fmt': Criteria.numFmtConditions, |
|
'string': Criteria.stringConditions |
|
}, |
|
depthLimit: false, |
|
filterChanged: undefined, |
|
greyscale: false, |
|
i18n: { |
|
add: 'Add Condition', |
|
button: { |
|
0: 'Search Builder', |
|
_: 'Search Builder (%d)' |
|
}, |
|
clearAll: 'Clear All', |
|
condition: 'Condition', |
|
conditions: { |
|
array: { |
|
contains: 'Contains', |
|
empty: 'Empty', |
|
equals: 'Equals', |
|
not: 'Not', |
|
notEmpty: 'Not Empty', |
|
without: 'Without' |
|
}, |
|
date: { |
|
after: 'After', |
|
before: 'Before', |
|
between: 'Between', |
|
empty: 'Empty', |
|
equals: 'Equals', |
|
not: 'Not', |
|
notBetween: 'Not Between', |
|
notEmpty: 'Not Empty' |
|
}, |
|
moment: { |
|
after: 'After', |
|
before: 'Before', |
|
between: 'Between', |
|
empty: 'Empty', |
|
equals: 'Equals', |
|
not: 'Not', |
|
notBetween: 'Not Between', |
|
notEmpty: 'Not Empty' |
|
}, |
|
number: { |
|
between: 'Between', |
|
empty: 'Empty', |
|
equals: 'Equals', |
|
gt: 'Greater Than', |
|
gte: 'Greater Than Equal To', |
|
lt: 'Less Than', |
|
lte: 'Less Than Equal To', |
|
not: 'Not', |
|
notBetween: 'Not Between', |
|
notEmpty: 'Not Empty' |
|
}, |
|
string: { |
|
contains: 'Contains', |
|
empty: 'Empty', |
|
endsWith: 'Ends With', |
|
equals: 'Equals', |
|
not: 'Not', |
|
notEmpty: 'Not Empty', |
|
startsWith: 'Starts With' |
|
} |
|
}, |
|
data: 'Data', |
|
deleteTitle: 'Delete filtering rule', |
|
leftTitle: 'Outdent criteria', |
|
logicAnd: 'And', |
|
logicOr: 'Or', |
|
rightTitle: 'Indent criteria', |
|
title: { |
|
0: 'Custom Search Builder', |
|
_: 'Custom Search Builder (%d)' |
|
}, |
|
value: 'Value', |
|
valueJoiner: 'and' |
|
}, |
|
logic: 'AND', |
|
orthogonal: { |
|
display: 'display', |
|
search: 'filter' |
|
}, |
|
preDefined: false |
|
}; |
|
return SearchBuilder; |
|
}()); |
|
|
|
/*! SearchBuilder 1.0.1 |
|
* ©2020 SpryMedia Ltd - datatables.net/license/mit |
|
*/ |
|
// DataTables extensions common UMD. Note that this allows for AMD, CommonJS |
|
// (with window and jQuery being allowed as parameters to the returned |
|
// function) or just default browser loading. |
|
(function (factory) { |
|
if (typeof define === 'function' && define.amd) { |
|
// AMD |
|
define(['jquery', 'datatables.net'], function ($) { |
|
return factory($, window, document); |
|
}); |
|
} |
|
else if (typeof exports === 'object') { |
|
// CommonJS |
|
module.exports = function (root, $) { |
|
if (!root) { |
|
root = window; |
|
} |
|
if (!$ || !$.fn.dataTable) { |
|
$ = require('datatables.net')(root, $).$; |
|
} |
|
return factory($, root, root.document); |
|
}; |
|
} |
|
else { |
|
// Browser - assume jQuery has already been loaded |
|
factory(window.jQuery, window, document); |
|
} |
|
}(function ($, window, document) { |
|
setJQuery$2($); |
|
setJQuery$1($); |
|
setJQuery($); |
|
var DataTable = $.fn.dataTable; |
|
$.fn.dataTable.SearchBuilder = SearchBuilder; |
|
$.fn.DataTable.SearchBuilder = SearchBuilder; |
|
$.fn.dataTable.Group = Group; |
|
$.fn.DataTable.Group = Group; |
|
$.fn.dataTable.Criteria = Criteria; |
|
$.fn.DataTable.Criteria = Criteria; |
|
var apiRegister = $.fn.dataTable.Api.register; |
|
// Set up object for plugins |
|
$.fn.dataTable.ext.searchBuilder = { |
|
conditions: {} |
|
}; |
|
$.fn.dataTable.ext.buttons.searchBuilder = { |
|
action: function (e, dt, node, config) { |
|
e.stopPropagation(); |
|
this.popover(config._searchBuilder.getNode(), { |
|
align: 'dt-container' |
|
}); |
|
}, |
|
config: {}, |
|
init: function (dt, node, config) { |
|
var sb = new $.fn.dataTable.SearchBuilder(dt, $.extend({ |
|
filterChanged: function (count, text) { |
|
dt.button(node).text(text); |
|
} |
|
}, config.config)); |
|
dt.button(node).text(config.text || dt.i18n('searchBuilder.button', sb.c.i18n.button, 0)); |
|
config._searchBuilder = sb; |
|
}, |
|
text: null |
|
}; |
|
apiRegister('searchBuilder.getDetails()', function () { |
|
var ctx = this.context[0]; |
|
return ctx._searchBuilder.getDetails(); |
|
}); |
|
apiRegister('searchBuilder.rebuild()', function (details) { |
|
var ctx = this.context[0]; |
|
ctx._searchBuilder.rebuild(details); |
|
return this; |
|
}); |
|
apiRegister('searchBuilder.container()', function () { |
|
var ctx = this.context[0]; |
|
return ctx._searchBuilder.getNode(); |
|
}); |
|
/** |
|
* Init function for SearchBuilder |
|
* @param settings the settings to be applied |
|
* @param options the options for SearchBuilder |
|
* @returns JQUERY<HTMLElement> Returns the node of the SearchBuilder |
|
*/ |
|
function _init(settings, options) { |
|
var api = new DataTable.Api(settings); |
|
var opts = options |
|
? options |
|
: api.init().searchBuilder || DataTable.defaults.searchBuilder; |
|
var searchBuilder = new SearchBuilder(api, opts); |
|
var node = searchBuilder.getNode(); |
|
return node; |
|
} |
|
// Attach a listener to the document which listens for DataTables initialisation |
|
// events so we can automatically initialise |
|
$(document).on('preInit.dt.dtsp', function (e, settings, json) { |
|
if (e.namespace !== 'dt') { |
|
return; |
|
} |
|
if (settings.oInit.searchBuilder || |
|
DataTable.defaults.searchBuilder) { |
|
if (!settings._searchBuilder) { |
|
_init(settings); |
|
} |
|
} |
|
}); |
|
// DataTables `dom` feature option |
|
DataTable.ext.feature.push({ |
|
cFeature: 'Q', |
|
fnInit: _init |
|
}); |
|
// DataTables 2 layout feature |
|
if (DataTable.ext.features) { |
|
DataTable.ext.features.register('searchBuilder', _init); |
|
} |
|
})); |
|
|
|
}());
|
|
|