1491 lines
61 KiB
JavaScript
1491 lines
61 KiB
JavaScript
/**
|
|
* @version: 2.0.11
|
|
* @author: Dan Grossman http://www.dangrossman.info/
|
|
* @copyright: Copyright (c) 2012-2015 Dan Grossman. All rights reserved.
|
|
* @license: Licensed under the MIT license. See http://www.opensource.org/licenses/mit-license.php
|
|
* @website: https://www.improvely.com/
|
|
*/
|
|
|
|
(function(root, factory) {
|
|
|
|
if (typeof define === 'function' && define.amd) {
|
|
define(['moment', 'jquery', 'exports'], function(momentjs, $, exports) {
|
|
root.daterangepicker = factory(root, exports, momentjs, $);
|
|
});
|
|
|
|
} else if (typeof exports !== 'undefined') {
|
|
var momentjs = require('moment');
|
|
var jQuery = window.jQuery;
|
|
if (jQuery === undefined) {
|
|
try {
|
|
jQuery = require('jquery');
|
|
} catch (err) {
|
|
if (!jQuery) throw new Error('jQuery dependency not found');
|
|
}
|
|
}
|
|
|
|
factory(root, exports, momentjs, jQuery);
|
|
|
|
// Finally, as a browser global.
|
|
} else {
|
|
root.daterangepicker = factory(root, {}, root.moment || moment, (root.jQuery || root.Zepto || root.ender || root.$));
|
|
}
|
|
|
|
}(this, function(root, daterangepicker, moment, $) {
|
|
|
|
var DateRangePicker = function(element, options, cb) {
|
|
|
|
//default settings for options
|
|
this.parentEl = 'body';
|
|
this.element = $(element);
|
|
this.startDate = moment().startOf('day');
|
|
this.endDate = moment().endOf('day');
|
|
this.timeZone = moment().utcOffset();
|
|
this.minDate = false;
|
|
this.maxDate = false;
|
|
this.dateLimit = false;
|
|
this.autoApply = false;
|
|
this.singleDatePicker = false;
|
|
this.showDropdowns = false;
|
|
this.showWeekNumbers = false;
|
|
this.timePicker = false;
|
|
this.timePicker24Hour = false;
|
|
this.timePickerIncrement = 1;
|
|
this.timePickerSeconds = false;
|
|
this.linkedCalendars = true;
|
|
this.autoUpdateInput = true;
|
|
this.ranges = {};
|
|
|
|
this.opens = 'right';
|
|
if (this.element.hasClass('pull-right'))
|
|
this.opens = 'left';
|
|
|
|
this.drops = 'down';
|
|
if (this.element.hasClass('dropup'))
|
|
this.drops = 'up';
|
|
|
|
this.buttonClasses = 'btn btn-sm';
|
|
this.applyClass = 'btn-success';
|
|
this.cancelClass = 'btn-default';
|
|
|
|
this.locale = {
|
|
format: 'MM/DD/YYYY',
|
|
separator: ' - ',
|
|
applyLabel: 'Apply',
|
|
cancelLabel: 'Cancel',
|
|
weekLabel: 'W',
|
|
customRangeLabel: 'Custom Range',
|
|
daysOfWeek: moment.weekdaysMin(),
|
|
monthNames: moment.monthsShort(),
|
|
firstDay: moment.localeData().firstDayOfWeek()
|
|
};
|
|
|
|
this.callback = function() { };
|
|
|
|
//some state information
|
|
this.isShowing = false;
|
|
this.leftCalendar = {};
|
|
this.rightCalendar = {};
|
|
|
|
//custom options from user
|
|
if (typeof options !== 'object' || options === null)
|
|
options = {};
|
|
|
|
//allow setting options with data attributes
|
|
//data-api options will be overwritten with custom javascript options
|
|
options = $.extend(this.element.data(), options);
|
|
|
|
//html template for the picker UI
|
|
if (typeof options.template !== 'string')
|
|
options.template = '<div class="daterangepicker dropdown-menu">' +
|
|
'<div class="calendar left">' +
|
|
'<div class="daterangepicker_input">' +
|
|
'<input class="input-mini" type="text" name="daterangepicker_start" value="" />' +
|
|
'<i class="fa fa-calendar glyphicon glyphicon-calendar"></i>' +
|
|
'<div class="calendar-time">' +
|
|
'<div></div>' +
|
|
'<i class="fa fa-clock-o glyphicon glyphicon-time"></i>' +
|
|
'</div>' +
|
|
'</div>' +
|
|
'<div class="calendar-table"></div>' +
|
|
'</div>' +
|
|
'<div class="calendar right">' +
|
|
'<div class="daterangepicker_input">' +
|
|
'<input class="input-mini" type="text" name="daterangepicker_end" value="" />' +
|
|
'<i class="fa fa-calendar glyphicon glyphicon-calendar"></i>' +
|
|
'<div class="calendar-time">' +
|
|
'<div></div>' +
|
|
'<i class="fa fa-clock-o glyphicon glyphicon-time"></i>' +
|
|
'</div>' +
|
|
'</div>' +
|
|
'<div class="calendar-table"></div>' +
|
|
'</div>' +
|
|
'<div class="ranges">' +
|
|
'<div class="range_inputs">' +
|
|
'<button class="applyBtn" disabled="disabled" type="button"></button> ' +
|
|
'<button class="cancelBtn" type="button"></button>' +
|
|
'</div>' +
|
|
'</div>' +
|
|
'</div>';
|
|
|
|
this.parentEl = (options.parentEl && $(options.parentEl).length) ? $(options.parentEl) : $(this.parentEl);
|
|
this.container = $(options.template).appendTo(this.parentEl);
|
|
|
|
//
|
|
// handle all the possible options overriding defaults
|
|
//
|
|
|
|
if (typeof options.locale === 'object') {
|
|
|
|
if (typeof options.locale.format === 'string')
|
|
this.locale.format = options.locale.format;
|
|
|
|
if (typeof options.locale.separator === 'string')
|
|
this.locale.separator = options.locale.separator;
|
|
|
|
if (typeof options.locale.daysOfWeek === 'object')
|
|
this.locale.daysOfWeek = options.locale.daysOfWeek.slice();
|
|
|
|
if (typeof options.locale.monthNames === 'object')
|
|
this.locale.monthNames = options.locale.monthNames.slice();
|
|
|
|
if (typeof options.locale.firstDay === 'number')
|
|
this.locale.firstDay = options.locale.firstDay;
|
|
|
|
if (typeof options.locale.applyLabel === 'string')
|
|
this.locale.applyLabel = options.locale.applyLabel;
|
|
|
|
if (typeof options.locale.cancelLabel === 'string')
|
|
this.locale.cancelLabel = options.locale.cancelLabel;
|
|
|
|
if (typeof options.locale.weekLabel === 'string')
|
|
this.locale.weekLabel = options.locale.weekLabel;
|
|
|
|
if (typeof options.locale.customRangeLabel === 'string')
|
|
this.locale.customRangeLabel = options.locale.customRangeLabel;
|
|
|
|
}
|
|
|
|
if (typeof options.startDate === 'string')
|
|
this.startDate = moment(options.startDate, this.locale.format);
|
|
|
|
if (typeof options.endDate === 'string')
|
|
this.endDate = moment(options.endDate, this.locale.format);
|
|
|
|
if (typeof options.minDate === 'string')
|
|
this.minDate = moment(options.minDate, this.locale.format);
|
|
|
|
if (typeof options.maxDate === 'string')
|
|
this.maxDate = moment(options.maxDate, this.locale.format);
|
|
|
|
if (typeof options.startDate === 'object')
|
|
this.startDate = moment(options.startDate);
|
|
|
|
if (typeof options.endDate === 'object')
|
|
this.endDate = moment(options.endDate);
|
|
|
|
if (typeof options.minDate === 'object')
|
|
this.minDate = moment(options.minDate);
|
|
|
|
if (typeof options.maxDate === 'object')
|
|
this.maxDate = moment(options.maxDate);
|
|
|
|
// sanity check for bad options
|
|
if (this.minDate && this.startDate.isBefore(this.minDate))
|
|
this.startDate = this.minDate.clone();
|
|
|
|
// sanity check for bad options
|
|
if (this.maxDate && this.endDate.isAfter(this.maxDate))
|
|
this.endDate = this.maxDate.clone();
|
|
|
|
if (typeof options.applyClass === 'string')
|
|
this.applyClass = options.applyClass;
|
|
|
|
if (typeof options.cancelClass === 'string')
|
|
this.cancelClass = options.cancelClass;
|
|
|
|
if (typeof options.dateLimit === 'object')
|
|
this.dateLimit = options.dateLimit;
|
|
|
|
if (typeof options.opens === 'string')
|
|
this.opens = options.opens;
|
|
|
|
if (typeof options.drops === 'string')
|
|
this.drops = options.drops;
|
|
|
|
if (typeof options.showWeekNumbers === 'boolean')
|
|
this.showWeekNumbers = options.showWeekNumbers;
|
|
|
|
if (typeof options.buttonClasses === 'string')
|
|
this.buttonClasses = options.buttonClasses;
|
|
|
|
if (typeof options.buttonClasses === 'object')
|
|
this.buttonClasses = options.buttonClasses.join(' ');
|
|
|
|
if (typeof options.showDropdowns === 'boolean')
|
|
this.showDropdowns = options.showDropdowns;
|
|
|
|
if (typeof options.singleDatePicker === 'boolean') {
|
|
this.singleDatePicker = options.singleDatePicker;
|
|
if (this.singleDatePicker)
|
|
this.endDate = this.startDate.clone();
|
|
}
|
|
|
|
if (typeof options.timePicker === 'boolean')
|
|
this.timePicker = options.timePicker;
|
|
|
|
if (typeof options.timePickerSeconds === 'boolean')
|
|
this.timePickerSeconds = options.timePickerSeconds;
|
|
|
|
if (typeof options.timePickerIncrement === 'number')
|
|
this.timePickerIncrement = options.timePickerIncrement;
|
|
|
|
if (typeof options.timePicker24Hour === 'boolean')
|
|
this.timePicker24Hour = options.timePicker24Hour;
|
|
|
|
if (typeof options.autoApply === 'boolean')
|
|
this.autoApply = options.autoApply;
|
|
|
|
if (typeof options.autoUpdateInput === 'boolean')
|
|
this.autoUpdateInput = options.autoUpdateInput;
|
|
|
|
if (typeof options.linkedCalendars === 'boolean')
|
|
this.linkedCalendars = options.linkedCalendars;
|
|
|
|
if (typeof options.isInvalidDate === 'function')
|
|
this.isInvalidDate = options.isInvalidDate;
|
|
|
|
// update day names order to firstDay
|
|
if (this.locale.firstDay != 0) {
|
|
var iterator = this.locale.firstDay;
|
|
while (iterator > 0) {
|
|
this.locale.daysOfWeek.push(this.locale.daysOfWeek.shift());
|
|
iterator--;
|
|
}
|
|
}
|
|
|
|
var start, end, range;
|
|
|
|
//if no start/end dates set, check if an input element contains initial values
|
|
if (typeof options.startDate === 'undefined' && typeof options.endDate === 'undefined') {
|
|
if ($(this.element).is('input[type=text]')) {
|
|
var val = $(this.element).val(),
|
|
split = val.split(this.locale.separator);
|
|
|
|
start = end = null;
|
|
|
|
if (split.length == 2) {
|
|
start = moment(split[0], this.locale.format);
|
|
end = moment(split[1], this.locale.format);
|
|
} else if (this.singleDatePicker && val !== "") {
|
|
start = moment(val, this.locale.format);
|
|
end = moment(val, this.locale.format);
|
|
}
|
|
if (start !== null && end !== null) {
|
|
this.setStartDate(start);
|
|
this.setEndDate(end);
|
|
}
|
|
}
|
|
}
|
|
|
|
// bind the time zone used to build the calendar to either the timeZone passed in through the options or the zone of the startDate (which will be the local time zone by default)
|
|
if (typeof options.timeZone === 'string' || typeof options.timeZone === 'number') {
|
|
if (typeof options.timeZone === 'string' && typeof moment.tz !== 'undefined') {
|
|
this.timeZone = moment.tz.zone(options.timeZone).parse(new Date) * -1; // Offset is positive if the timezone is behind UTC and negative if it is ahead.
|
|
} else {
|
|
this.timeZone = options.timeZone;
|
|
}
|
|
this.startDate.utcOffset(this.timeZone);
|
|
this.endDate.utcOffset(this.timeZone);
|
|
} else {
|
|
this.timeZone = moment(this.startDate).utcOffset();
|
|
}
|
|
|
|
if (typeof options.ranges === 'object') {
|
|
for (range in options.ranges) {
|
|
|
|
if (typeof options.ranges[range][0] === 'string')
|
|
start = moment(options.ranges[range][0], this.locale.format);
|
|
else
|
|
start = moment(options.ranges[range][0]);
|
|
|
|
if (typeof options.ranges[range][1] === 'string')
|
|
end = moment(options.ranges[range][1], this.locale.format);
|
|
else
|
|
end = moment(options.ranges[range][1]);
|
|
|
|
// If the start or end date exceed those allowed by the minDate or dateLimit
|
|
// options, shorten the range to the allowable period.
|
|
if (this.minDate && start.isBefore(this.minDate))
|
|
start = this.minDate.clone();
|
|
|
|
var maxDate = this.maxDate;
|
|
if (this.dateLimit && start.clone().add(this.dateLimit).isAfter(maxDate))
|
|
maxDate = start.clone().add(this.dateLimit);
|
|
if (maxDate && end.isAfter(maxDate))
|
|
end = maxDate.clone();
|
|
|
|
// If the end of the range is before the minimum or the start of the range is
|
|
// after the maximum, don't display this range option at all.
|
|
if ((this.minDate && end.isBefore(this.minDate)) || (maxDate && start.isAfter(maxDate)))
|
|
continue;
|
|
|
|
this.ranges[range] = [start, end];
|
|
}
|
|
|
|
var list = '<ul>';
|
|
for (range in this.ranges) {
|
|
list += '<li>' + range + '</li>';
|
|
}
|
|
list += '<li>' + this.locale.customRangeLabel + '</li>';
|
|
list += '</ul>';
|
|
this.container.find('.ranges').prepend(list);
|
|
}
|
|
|
|
if (typeof cb === 'function') {
|
|
this.callback = cb;
|
|
}
|
|
|
|
if (!this.timePicker) {
|
|
this.startDate = this.startDate.startOf('day');
|
|
this.endDate = this.endDate.endOf('day');
|
|
this.container.find('.calendar-time').hide();
|
|
}
|
|
|
|
//can't be used together for now
|
|
if (this.timePicker && this.autoApply)
|
|
this.autoApply = false;
|
|
|
|
if (this.autoApply && typeof options.ranges !== 'object') {
|
|
this.container.find('.ranges').hide();
|
|
} else if (this.autoApply) {
|
|
this.container.find('.applyBtn, .cancelBtn').addClass('hide');
|
|
}
|
|
|
|
if (this.singleDatePicker) {
|
|
this.container.addClass('single');
|
|
this.container.find('.calendar.left').addClass('single');
|
|
this.container.find('.calendar.left').show();
|
|
this.container.find('.calendar.right').hide();
|
|
this.container.find('.daterangepicker_input input, .daterangepicker_input i').hide();
|
|
if (!this.timePicker) {
|
|
this.container.find('.ranges').hide();
|
|
}
|
|
}
|
|
|
|
if (typeof options.ranges === 'undefined' && !this.singleDatePicker) {
|
|
this.container.addClass('show-calendar');
|
|
}
|
|
|
|
this.container.addClass('opens' + this.opens);
|
|
|
|
//swap the position of the predefined ranges if opens right
|
|
if (typeof options.ranges !== 'undefined' && this.opens == 'right') {
|
|
var ranges = this.container.find('.ranges');
|
|
var html = ranges.clone();
|
|
ranges.remove();
|
|
this.container.find('.calendar.left').parent().prepend(html);
|
|
}
|
|
|
|
//apply CSS classes and labels to buttons
|
|
this.container.find('.applyBtn, .cancelBtn').addClass(this.buttonClasses);
|
|
if (this.applyClass.length)
|
|
this.container.find('.applyBtn').addClass(this.applyClass);
|
|
if (this.cancelClass.length)
|
|
this.container.find('.cancelBtn').addClass(this.cancelClass);
|
|
this.container.find('.applyBtn').html(this.locale.applyLabel);
|
|
this.container.find('.cancelBtn').html(this.locale.cancelLabel);
|
|
|
|
//
|
|
// event listeners
|
|
//
|
|
|
|
this.container.find('.calendar')
|
|
.on('click.daterangepicker', '.prev', $.proxy(this.clickPrev, this))
|
|
.on('click.daterangepicker', '.next', $.proxy(this.clickNext, this))
|
|
.on('click.daterangepicker', 'td.available', $.proxy(this.clickDate, this))
|
|
.on('mouseenter.daterangepicker', 'td.available', $.proxy(this.hoverDate, this))
|
|
.on('mouseleave.daterangepicker', 'td.available', $.proxy(this.updateFormInputs, this))
|
|
.on('change.daterangepicker', 'select.yearselect', $.proxy(this.monthOrYearChanged, this))
|
|
.on('change.daterangepicker', 'select.monthselect', $.proxy(this.monthOrYearChanged, this))
|
|
.on('change.daterangepicker', 'select.hourselect,select.minuteselect,select.secondselect,select.ampmselect', $.proxy(this.timeChanged, this))
|
|
.on('click.daterangepicker', '.daterangepicker_input input', $.proxy(this.showCalendars, this))
|
|
//.on('keyup.daterangepicker', '.daterangepicker_input input', $.proxy(this.formInputsChanged, this))
|
|
.on('change.daterangepicker', '.daterangepicker_input input', $.proxy(this.formInputsChanged, this));
|
|
|
|
this.container.find('.ranges')
|
|
.on('click.daterangepicker', 'button.applyBtn', $.proxy(this.clickApply, this))
|
|
.on('click.daterangepicker', 'button.cancelBtn', $.proxy(this.clickCancel, this))
|
|
.on('click.daterangepicker', 'li', $.proxy(this.clickRange, this))
|
|
.on('mouseenter.daterangepicker', 'li', $.proxy(this.hoverRange, this))
|
|
.on('mouseleave.daterangepicker', 'li', $.proxy(this.updateFormInputs, this));
|
|
|
|
if (this.element.is('input')) {
|
|
this.element.on({
|
|
'click.daterangepicker': $.proxy(this.show, this),
|
|
'focus.daterangepicker': $.proxy(this.show, this),
|
|
'keyup.daterangepicker': $.proxy(this.elementChanged, this),
|
|
'keydown.daterangepicker': $.proxy(this.keydown, this)
|
|
});
|
|
} else {
|
|
this.element.on('click.daterangepicker', $.proxy(this.toggle, this));
|
|
}
|
|
|
|
//
|
|
// if attached to a text input, set the initial value
|
|
//
|
|
|
|
if (this.element.is('input') && !this.singleDatePicker && this.autoUpdateInput) {
|
|
this.element.val(this.startDate.format(this.locale.format) + this.locale.separator + this.endDate.format(this.locale.format));
|
|
this.element.trigger('change');
|
|
} else if (this.element.is('input') && this.autoUpdateInput) {
|
|
this.element.val(this.startDate.format(this.locale.format));
|
|
this.element.trigger('change');
|
|
}
|
|
|
|
};
|
|
|
|
DateRangePicker.prototype = {
|
|
|
|
constructor: DateRangePicker,
|
|
|
|
setStartDate: function(startDate) {
|
|
if (typeof startDate === 'string')
|
|
this.startDate = moment(startDate, this.locale.format).utcOffset(this.timeZone);
|
|
|
|
if (typeof startDate === 'object')
|
|
this.startDate = moment(startDate);
|
|
|
|
if (!this.timePicker)
|
|
this.startDate = this.startDate.startOf('day');
|
|
|
|
if (this.timePicker && this.timePickerIncrement)
|
|
this.startDate.minute(Math.round(this.startDate.minute() / this.timePickerIncrement) * this.timePickerIncrement);
|
|
|
|
if (this.minDate && this.startDate.isBefore(this.minDate))
|
|
this.startDate = this.minDate;
|
|
|
|
if (this.maxDate && this.startDate.isAfter(this.maxDate))
|
|
this.startDate = this.maxDate;
|
|
|
|
if (!this.isShowing)
|
|
this.updateElement();
|
|
|
|
this.updateMonthsInView();
|
|
},
|
|
|
|
setEndDate: function(endDate) {
|
|
if (typeof endDate === 'string')
|
|
this.endDate = moment(endDate, this.locale.format).utcOffset(this.timeZone);
|
|
|
|
if (typeof endDate === 'object')
|
|
this.endDate = moment(endDate);
|
|
|
|
if (!this.timePicker)
|
|
this.endDate = this.endDate.endOf('day');
|
|
|
|
if (this.timePicker && this.timePickerIncrement)
|
|
this.endDate.minute(Math.round(this.endDate.minute() / this.timePickerIncrement) * this.timePickerIncrement);
|
|
|
|
if (this.endDate.isBefore(this.startDate))
|
|
this.endDate = this.startDate.clone();
|
|
|
|
if (this.maxDate && this.endDate.isAfter(this.maxDate))
|
|
this.endDate = this.maxDate;
|
|
|
|
if (this.dateLimit && this.startDate.clone().add(this.dateLimit).isBefore(this.endDate))
|
|
this.endDate = this.startDate.clone().add(this.dateLimit);
|
|
|
|
if (!this.isShowing)
|
|
this.updateElement();
|
|
|
|
this.updateMonthsInView();
|
|
},
|
|
|
|
isInvalidDate: function() {
|
|
return false;
|
|
},
|
|
|
|
updateView: function() {
|
|
if (this.timePicker) {
|
|
this.renderTimePicker('left');
|
|
this.renderTimePicker('right');
|
|
if (!this.endDate) {
|
|
this.container.find('.right .calendar-time select').attr('disabled', 'disabled').addClass('disabled');
|
|
} else {
|
|
this.container.find('.right .calendar-time select').removeAttr('disabled').removeClass('disabled');
|
|
}
|
|
}
|
|
if (this.endDate) {
|
|
this.container.find('input[name="daterangepicker_end"]').removeClass('active');
|
|
this.container.find('input[name="daterangepicker_start"]').addClass('active');
|
|
} else {
|
|
this.container.find('input[name="daterangepicker_end"]').addClass('active');
|
|
this.container.find('input[name="daterangepicker_start"]').removeClass('active');
|
|
}
|
|
this.updateMonthsInView();
|
|
this.updateCalendars();
|
|
this.updateFormInputs();
|
|
},
|
|
|
|
updateMonthsInView: function() {
|
|
if (this.endDate) {
|
|
|
|
//if both dates are visible already, do nothing
|
|
if (this.leftCalendar.month && this.rightCalendar.month &&
|
|
(this.startDate.format('YYYY-MM') == this.leftCalendar.month.format('YYYY-MM') || this.startDate.format('YYYY-MM') == this.rightCalendar.month.format('YYYY-MM'))
|
|
&&
|
|
(this.endDate.format('YYYY-MM') == this.leftCalendar.month.format('YYYY-MM') || this.endDate.format('YYYY-MM') == this.rightCalendar.month.format('YYYY-MM'))
|
|
) {
|
|
return;
|
|
}
|
|
|
|
this.leftCalendar.month = this.startDate.clone().date(2);
|
|
if (!this.linkedCalendars && (this.endDate.month() != this.startDate.month() || this.endDate.year() != this.startDate.year())) {
|
|
this.rightCalendar.month = this.endDate.clone().date(2);
|
|
} else {
|
|
this.rightCalendar.month = this.startDate.clone().date(2).add(1, 'month');
|
|
}
|
|
|
|
} else {
|
|
if (this.leftCalendar.month.format('YYYY-MM') != this.startDate.format('YYYY-MM') && this.rightCalendar.month.format('YYYY-MM') != this.startDate.format('YYYY-MM')) {
|
|
this.leftCalendar.month = this.startDate.clone().date(2);
|
|
this.rightCalendar.month = this.startDate.clone().date(2).add(1, 'month');
|
|
}
|
|
}
|
|
},
|
|
|
|
updateCalendars: function() {
|
|
|
|
if (this.timePicker) {
|
|
var hour, minute, second;
|
|
if (this.endDate) {
|
|
hour = parseInt(this.container.find('.left .hourselect').val(), 10);
|
|
minute = parseInt(this.container.find('.left .minuteselect').val(), 10);
|
|
second = this.timePickerSeconds ? parseInt(this.container.find('.left .secondselect').val(), 10) : 0;
|
|
if (!this.timePicker24Hour) {
|
|
var ampm = this.container.find('.left .ampmselect').val();
|
|
if (ampm === 'PM' && hour < 12)
|
|
hour += 12;
|
|
if (ampm === 'AM' && hour === 12)
|
|
hour = 0;
|
|
}
|
|
} else {
|
|
hour = parseInt(this.container.find('.right .hourselect').val(), 10);
|
|
minute = parseInt(this.container.find('.right .minuteselect').val(), 10);
|
|
second = this.timePickerSeconds ? parseInt(this.container.find('.right .secondselect').val(), 10) : 0;
|
|
if (!this.timePicker24Hour) {
|
|
var ampm = this.container.find('.left .ampmselect').val();
|
|
if (ampm === 'PM' && hour < 12)
|
|
hour += 12;
|
|
if (ampm === 'AM' && hour === 12)
|
|
hour = 0;
|
|
}
|
|
}
|
|
this.leftCalendar.month.hour(hour).minute(minute).second(second);
|
|
this.rightCalendar.month.hour(hour).minute(minute).second(second);
|
|
}
|
|
|
|
this.renderCalendar('left');
|
|
this.renderCalendar('right');
|
|
|
|
//highlight any predefined range matching the current start and end dates
|
|
this.container.find('.ranges li').removeClass('active');
|
|
if (this.endDate == null) return;
|
|
|
|
var customRange = true;
|
|
var i = 0;
|
|
for (var range in this.ranges) {
|
|
if (this.timePicker) {
|
|
if (this.startDate.isSame(this.ranges[range][0]) && this.endDate.isSame(this.ranges[range][1])) {
|
|
customRange = false;
|
|
this.chosenLabel = this.container.find('.ranges li:eq(' + i + ')').addClass('active').html();
|
|
break;
|
|
}
|
|
} else {
|
|
//ignore times when comparing dates if time picker is not enabled
|
|
if (this.startDate.format('YYYY-MM-DD') == this.ranges[range][0].format('YYYY-MM-DD') && this.endDate.format('YYYY-MM-DD') == this.ranges[range][1].format('YYYY-MM-DD')) {
|
|
customRange = false;
|
|
this.chosenLabel = this.container.find('.ranges li:eq(' + i + ')').addClass('active').html();
|
|
break;
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
if (customRange) {
|
|
this.chosenLabel = this.container.find('.ranges li:last').addClass('active').html();
|
|
this.showCalendars();
|
|
}
|
|
|
|
},
|
|
|
|
renderCalendar: function(side) {
|
|
|
|
//
|
|
// Build the matrix of dates that will populate the calendar
|
|
//
|
|
|
|
var calendar = side == 'left' ? this.leftCalendar : this.rightCalendar;
|
|
var month = calendar.month.month();
|
|
var year = calendar.month.year();
|
|
var hour = calendar.month.hour();
|
|
var minute = calendar.month.minute();
|
|
var second = calendar.month.second();
|
|
var daysInMonth = moment([year, month]).daysInMonth();
|
|
var firstDay = moment([year, month, 1]);
|
|
var lastDay = moment([year, month, daysInMonth]);
|
|
var lastMonth = moment(firstDay).subtract(1, 'month').month();
|
|
var lastYear = moment(firstDay).subtract(1, 'month').year();
|
|
var daysInLastMonth = moment([lastYear, lastMonth]).daysInMonth();
|
|
var dayOfWeek = firstDay.day();
|
|
|
|
//initialize a 6 rows x 7 columns array for the calendar
|
|
var calendar = [];
|
|
calendar.firstDay = firstDay;
|
|
calendar.lastDay = lastDay;
|
|
|
|
for (var i = 0; i < 6; i++) {
|
|
calendar[i] = [];
|
|
}
|
|
|
|
//populate the calendar with date objects
|
|
var startDay = daysInLastMonth - dayOfWeek + this.locale.firstDay + 1;
|
|
if (startDay > daysInLastMonth)
|
|
startDay -= 7;
|
|
|
|
if (dayOfWeek == this.locale.firstDay)
|
|
startDay = daysInLastMonth - 6;
|
|
|
|
// Possible patch for issue #626 https://github.com/dangrossman/bootstrap-daterangepicker/issues/626
|
|
var curDate = moment([lastYear, lastMonth, startDay, 12, minute, second]).utcOffset(this.timeZone); // .utcOffset(this.timeZone);
|
|
|
|
var col, row;
|
|
for (var i = 0, col = 0, row = 0; i < 42; i++, col++, curDate = moment(curDate).add(24, 'hour')) {
|
|
if (i > 0 && col % 7 === 0) {
|
|
col = 0;
|
|
row++;
|
|
}
|
|
calendar[row][col] = curDate.clone().hour(hour).minute(minute).second(second);
|
|
curDate.hour(12);
|
|
|
|
if (this.minDate && calendar[row][col].format('YYYY-MM-DD') == this.minDate.format('YYYY-MM-DD') && calendar[row][col].isBefore(this.minDate) && side == 'left') {
|
|
calendar[row][col] = this.minDate.clone();
|
|
}
|
|
|
|
if (this.maxDate && calendar[row][col].format('YYYY-MM-DD') == this.maxDate.format('YYYY-MM-DD') && calendar[row][col].isAfter(this.maxDate) && side == 'right') {
|
|
calendar[row][col] = this.maxDate.clone();
|
|
}
|
|
|
|
}
|
|
|
|
//make the calendar object available to hoverDate/clickDate
|
|
if (side == 'left') {
|
|
this.leftCalendar.calendar = calendar;
|
|
} else {
|
|
this.rightCalendar.calendar = calendar;
|
|
}
|
|
|
|
//
|
|
// Display the calendar
|
|
//
|
|
|
|
var minDate = side == 'left' ? this.minDate : this.startDate;
|
|
var maxDate = this.maxDate;
|
|
var selected = side == 'left' ? this.startDate : this.endDate;
|
|
|
|
var html = '<table class="table-condensed">';
|
|
html += '<thead>';
|
|
html += '<tr>';
|
|
|
|
// add empty cell for week number
|
|
if (this.showWeekNumbers)
|
|
html += '<th></th>';
|
|
|
|
if ((!minDate || minDate.isBefore(calendar.firstDay)) && (!this.linkedCalendars || side == 'left')) {
|
|
html += '<th class="prev available"><i class="fa fa-chevron-left glyphicon glyphicon-chevron-left"></i></th>';
|
|
} else {
|
|
html += '<th></th>';
|
|
}
|
|
|
|
var dateHtml = this.locale.monthNames[calendar[1][1].month()] + calendar[1][1].format(" YYYY");
|
|
|
|
if (this.showDropdowns) {
|
|
var currentMonth = calendar[1][1].month();
|
|
var currentYear = calendar[1][1].year();
|
|
var maxYear = (maxDate && maxDate.year()) || (currentYear + 5);
|
|
var minYear = (minDate && minDate.year()) || (currentYear - 50);
|
|
var inMinYear = currentYear == minYear;
|
|
var inMaxYear = currentYear == maxYear;
|
|
|
|
var monthHtml = '<select class="monthselect">';
|
|
for (var m = 0; m < 12; m++) {
|
|
if ((!inMinYear || m >= minDate.month()) && (!inMaxYear || m <= maxDate.month())) {
|
|
monthHtml += "<option value='" + m + "'" +
|
|
(m === currentMonth ? " selected='selected'" : "") +
|
|
">" + this.locale.monthNames[m] + "</option>";
|
|
} else {
|
|
monthHtml += "<option value='" + m + "'" +
|
|
(m === currentMonth ? " selected='selected'" : "") +
|
|
" disabled='disabled'>" + this.locale.monthNames[m] + "</option>";
|
|
}
|
|
}
|
|
monthHtml += "</select>";
|
|
|
|
var yearHtml = '<select class="yearselect">';
|
|
for (var y = minYear; y <= maxYear; y++) {
|
|
yearHtml += '<option value="' + y + '"' +
|
|
(y === currentYear ? ' selected="selected"' : '') +
|
|
'>' + y + '</option>';
|
|
}
|
|
yearHtml += '</select>';
|
|
|
|
dateHtml = monthHtml + yearHtml;
|
|
}
|
|
|
|
html += '<th colspan="5" class="month">' + dateHtml + '</th>';
|
|
if ((!maxDate || maxDate.isAfter(calendar.lastDay)) && (!this.linkedCalendars || side == 'right' || this.singleDatePicker)) {
|
|
html += '<th class="next available"><i class="fa fa-chevron-right glyphicon glyphicon-chevron-right"></i></th>';
|
|
} else {
|
|
html += '<th></th>';
|
|
}
|
|
|
|
html += '</tr>';
|
|
html += '<tr>';
|
|
|
|
// add week number label
|
|
if (this.showWeekNumbers)
|
|
html += '<th class="week">' + this.locale.weekLabel + '</th>';
|
|
|
|
$.each(this.locale.daysOfWeek, function(index, dayOfWeek) {
|
|
html += '<th>' + dayOfWeek + '</th>';
|
|
});
|
|
|
|
html += '</tr>';
|
|
html += '</thead>';
|
|
html += '<tbody>';
|
|
|
|
//adjust maxDate to reflect the dateLimit setting in order to
|
|
//grey out end dates beyond the dateLimit
|
|
if (this.endDate == null && this.dateLimit) {
|
|
var maxLimit = this.startDate.clone().add(this.dateLimit).endOf('day');
|
|
if (!maxDate || maxLimit.isBefore(maxDate)) {
|
|
maxDate = maxLimit;
|
|
}
|
|
}
|
|
|
|
for (var row = 0; row < 6; row++) {
|
|
html += '<tr>';
|
|
|
|
// add week number
|
|
if (this.showWeekNumbers)
|
|
html += '<td class="week">' + calendar[row][0].week() + '</td>';
|
|
|
|
for (var col = 0; col < 7; col++) {
|
|
|
|
var classes = [];
|
|
|
|
//highlight today's date
|
|
if (calendar[row][col].isSame(new Date(), "day"))
|
|
classes.push('today');
|
|
|
|
//highlight weekends
|
|
if (calendar[row][col].isoWeekday() > 5)
|
|
classes.push('weekend');
|
|
|
|
//grey out the dates in other months displayed at beginning and end of this calendar
|
|
if (calendar[row][col].month() != calendar[1][1].month())
|
|
classes.push('off');
|
|
|
|
//don't allow selection of dates before the minimum date
|
|
if (this.minDate && calendar[row][col].isBefore(this.minDate, 'day'))
|
|
classes.push('off', 'disabled');
|
|
|
|
//don't allow selection of dates after the maximum date
|
|
if (maxDate && calendar[row][col].isAfter(maxDate, 'day'))
|
|
classes.push('off', 'disabled');
|
|
|
|
//don't allow selection of date if a custom function decides it's invalid
|
|
if (this.isInvalidDate(calendar[row][col]))
|
|
classes.push('off', 'disabled');
|
|
|
|
//highlight the currently selected start date
|
|
if (calendar[row][col].format('YYYY-MM-DD') == this.startDate.format('YYYY-MM-DD'))
|
|
classes.push('active', 'start-date');
|
|
|
|
//highlight the currently selected end date
|
|
if (this.endDate != null && calendar[row][col].format('YYYY-MM-DD') == this.endDate.format('YYYY-MM-DD'))
|
|
classes.push('active', 'end-date');
|
|
|
|
//highlight dates in-between the selected dates
|
|
if (this.endDate != null && calendar[row][col] > this.startDate && calendar[row][col] < this.endDate)
|
|
classes.push('in-range');
|
|
|
|
var cname = '', disabled = false;
|
|
for (var i = 0; i < classes.length; i++) {
|
|
cname += classes[i] + ' ';
|
|
if (classes[i] == 'disabled')
|
|
disabled = true;
|
|
}
|
|
if (!disabled)
|
|
cname += 'available';
|
|
|
|
html += '<td class="' + cname.replace(/^\s+|\s+$/g, '') + '" data-title="' + 'r' + row + 'c' + col + '">' + calendar[row][col].date() + '</td>';
|
|
|
|
}
|
|
html += '</tr>';
|
|
}
|
|
|
|
html += '</tbody>';
|
|
html += '</table>';
|
|
|
|
this.container.find('.calendar.' + side + ' .calendar-table').html(html);
|
|
|
|
},
|
|
|
|
renderTimePicker: function(side) {
|
|
|
|
var html, selected, minDate, maxDate = this.maxDate;
|
|
|
|
if (this.dateLimit && (!this.maxDate || this.startDate.clone().add(this.dateLimit).isAfter(this.maxDate)))
|
|
maxDate = this.startDate.clone().add(this.dateLimit);
|
|
|
|
if (side == 'left') {
|
|
selected = this.startDate.clone();
|
|
minDate = this.minDate;
|
|
} else if (side == 'right') {
|
|
selected = this.endDate ? this.endDate.clone() : this.startDate.clone();
|
|
minDate = this.startDate;
|
|
}
|
|
|
|
//
|
|
// hours
|
|
//
|
|
|
|
html = '<select class="hourselect">';
|
|
|
|
var start = this.timePicker24Hour ? 0 : 1;
|
|
var end = this.timePicker24Hour ? 23 : 12;
|
|
|
|
for (var i = start; i <= end; i++) {
|
|
var i_in_24 = i;
|
|
if (!this.timePicker24Hour)
|
|
i_in_24 = selected.hour() >= 12 ? (i == 12 ? 12 : i + 12) : (i == 12 ? 0 : i);
|
|
|
|
var time = selected.clone().hour(i_in_24);
|
|
var disabled = false;
|
|
if (minDate && time.minute(59).isBefore(minDate))
|
|
disabled = true;
|
|
if (maxDate && time.minute(0).isAfter(maxDate))
|
|
disabled = true;
|
|
|
|
if (i_in_24 == selected.hour() && !disabled) {
|
|
html += '<option value="' + i + '" selected="selected">' + i + '</option>';
|
|
} else if (disabled) {
|
|
html += '<option value="' + i + '" disabled="disabled" class="disabled">' + i + '</option>';
|
|
} else {
|
|
html += '<option value="' + i + '">' + i + '</option>';
|
|
}
|
|
}
|
|
|
|
html += '</select> ';
|
|
|
|
//
|
|
// minutes
|
|
//
|
|
|
|
html += ': <select class="minuteselect">';
|
|
|
|
for (var i = 0; i < 60; i += this.timePickerIncrement) {
|
|
var padded = i < 10 ? '0' + i : i;
|
|
var time = selected.clone().minute(i);
|
|
|
|
var disabled = false;
|
|
if (minDate && time.second(59).isBefore(minDate))
|
|
disabled = true;
|
|
if (maxDate && time.second(0).isAfter(maxDate))
|
|
disabled = true;
|
|
|
|
if (selected.minute() == i && !disabled) {
|
|
html += '<option value="' + i + '" selected="selected">' + padded + '</option>';
|
|
} else if (disabled) {
|
|
html += '<option value="' + i + '" disabled="disabled" class="disabled">' + padded + '</option>';
|
|
} else {
|
|
html += '<option value="' + i + '">' + padded + '</option>';
|
|
}
|
|
}
|
|
|
|
html += '</select> ';
|
|
|
|
//
|
|
// seconds
|
|
//
|
|
|
|
if (this.timePickerSeconds) {
|
|
html += ': <select class="secondselect">';
|
|
|
|
for (var i = 0; i < 60; i++) {
|
|
var padded = i < 10 ? '0' + i : i;
|
|
var time = selected.clone().second(i);
|
|
|
|
var disabled = false;
|
|
if (minDate && time.isBefore(minDate))
|
|
disabled = true;
|
|
if (maxDate && time.isAfter(maxDate))
|
|
disabled = true;
|
|
|
|
if (selected.second() == i && !disabled) {
|
|
html += '<option value="' + i + '" selected="selected">' + padded + '</option>';
|
|
} else if (disabled) {
|
|
html += '<option value="' + i + '" disabled="disabled" class="disabled">' + padded + '</option>';
|
|
} else {
|
|
html += '<option value="' + i + '">' + padded + '</option>';
|
|
}
|
|
}
|
|
|
|
html += '</select> ';
|
|
}
|
|
|
|
//
|
|
// AM/PM
|
|
//
|
|
|
|
if (!this.timePicker24Hour) {
|
|
html += '<select class="ampmselect">';
|
|
|
|
var am_html = '';
|
|
var pm_html = '';
|
|
|
|
if (minDate && selected.clone().hour(12).minute(0).second(0).isBefore(minDate))
|
|
am_html = ' disabled="disabled" class="disabled"';
|
|
|
|
if (maxDate && selected.clone().hour(0).minute(0).second(0).isAfter(maxDate))
|
|
pm_html = ' disabled="disabled" class="disabled"';
|
|
|
|
if (selected.hour() >= 12) {
|
|
html += '<option value="AM"' + am_html + '>AM</option><option value="PM" selected="selected"' + pm_html + '>PM</option>';
|
|
} else {
|
|
html += '<option value="AM" selected="selected"' + am_html + '>AM</option><option value="PM"' + pm_html + '>PM</option>';
|
|
}
|
|
|
|
html += '</select>';
|
|
}
|
|
|
|
this.container.find('.calendar.' + side + ' .calendar-time div').html(html);
|
|
|
|
},
|
|
|
|
updateFormInputs: function() {
|
|
|
|
//ignore mouse movements while an above-calendar text input has focus
|
|
if (this.container.find('input[name=daterangepicker_start]').is(":focus") || this.container.find('input[name=daterangepicker_end]').is(":focus"))
|
|
return;
|
|
|
|
this.container.find('input[name=daterangepicker_start]').val(this.startDate.format(this.locale.format));
|
|
if (this.endDate)
|
|
this.container.find('input[name=daterangepicker_end]').val(this.endDate.format(this.locale.format));
|
|
|
|
if (this.singleDatePicker || (this.endDate && (this.startDate.isBefore(this.endDate) || this.startDate.isSame(this.endDate)))) {
|
|
this.container.find('button.applyBtn').removeAttr('disabled');
|
|
} else {
|
|
this.container.find('button.applyBtn').attr('disabled', 'disabled');
|
|
}
|
|
|
|
},
|
|
|
|
move: function() {
|
|
var parentOffset = { top: 0, left: 0 },
|
|
containerTop;
|
|
var parentRightEdge = $(window).width();
|
|
if (!this.parentEl.is('body')) {
|
|
parentOffset = {
|
|
top: this.parentEl.offset().top - this.parentEl.scrollTop(),
|
|
left: this.parentEl.offset().left - this.parentEl.scrollLeft()
|
|
};
|
|
parentRightEdge = this.parentEl[0].clientWidth + this.parentEl.offset().left;
|
|
}
|
|
|
|
if (this.drops == 'up')
|
|
containerTop = this.element.offset().top - this.container.outerHeight() - parentOffset.top;
|
|
else
|
|
containerTop = this.element.offset().top + this.element.outerHeight() - parentOffset.top;
|
|
this.container[this.drops == 'up' ? 'addClass' : 'removeClass']('dropup');
|
|
|
|
if (this.opens == 'left') {
|
|
this.container.css({
|
|
top: containerTop,
|
|
right: parentRightEdge - this.element.offset().left - this.element.outerWidth(),
|
|
left: 'auto'
|
|
});
|
|
if (this.container.offset().left < 0) {
|
|
this.container.css({
|
|
right: 'auto',
|
|
left: 9
|
|
});
|
|
}
|
|
} else if (this.opens == 'center') {
|
|
this.container.css({
|
|
top: containerTop,
|
|
left: this.element.offset().left - parentOffset.left + this.element.outerWidth() / 2
|
|
- this.container.outerWidth() / 2,
|
|
right: 'auto'
|
|
});
|
|
if (this.container.offset().left < 0) {
|
|
this.container.css({
|
|
right: 'auto',
|
|
left: 9
|
|
});
|
|
}
|
|
} else {
|
|
this.container.css({
|
|
top: containerTop,
|
|
left: this.element.offset().left - parentOffset.left,
|
|
right: 'auto'
|
|
});
|
|
if (this.container.offset().left + this.container.outerWidth() > $(window).width()) {
|
|
this.container.css({
|
|
left: 'auto',
|
|
right: 0
|
|
});
|
|
}
|
|
}
|
|
},
|
|
|
|
show: function(e) {
|
|
if (this.isShowing) return;
|
|
|
|
// Create a click proxy that is private to this instance of datepicker, for unbinding
|
|
this._outsideClickProxy = $.proxy(function(e) { this.outsideClick(e); }, this);
|
|
// Bind global datepicker mousedown for hiding and
|
|
$(document)
|
|
.on('mousedown.daterangepicker', this._outsideClickProxy)
|
|
// also support mobile devices
|
|
.on('touchend.daterangepicker', this._outsideClickProxy)
|
|
// also explicitly play nice with Bootstrap dropdowns, which stopPropagation when clicking them
|
|
.on('click.daterangepicker', '[data-toggle=dropdown]', this._outsideClickProxy)
|
|
// and also close when focus changes to outside the picker (eg. tabbing between controls)
|
|
.on('focusin.daterangepicker', this._outsideClickProxy);
|
|
|
|
this.oldStartDate = this.startDate.clone();
|
|
this.oldEndDate = this.endDate.clone();
|
|
|
|
this.updateView();
|
|
this.container.show();
|
|
this.move();
|
|
this.element.trigger('show.daterangepicker', this);
|
|
this.isShowing = true;
|
|
},
|
|
|
|
hide: function(e) {
|
|
if (!this.isShowing) return;
|
|
|
|
//incomplete date selection, revert to last values
|
|
if (!this.endDate) {
|
|
this.startDate = this.oldStartDate.clone();
|
|
this.endDate = this.oldEndDate.clone();
|
|
}
|
|
|
|
//if a new date range was selected, invoke the user callback function
|
|
if (!this.startDate.isSame(this.oldStartDate) || !this.endDate.isSame(this.oldEndDate))
|
|
this.callback(this.startDate, this.endDate, this.chosenLabel);
|
|
|
|
//if picker is attached to a text input, update it
|
|
this.updateElement();
|
|
|
|
$(document).off('.daterangepicker');
|
|
this.container.hide();
|
|
this.element.trigger('hide.daterangepicker', this);
|
|
this.isShowing = false;
|
|
},
|
|
|
|
toggle: function(e) {
|
|
if (this.isShowing) {
|
|
this.hide();
|
|
} else {
|
|
this.show();
|
|
}
|
|
},
|
|
|
|
outsideClick: function(e) {
|
|
var target = $(e.target);
|
|
// if the page is clicked anywhere except within the daterangerpicker/button
|
|
// itself then call this.hide()
|
|
if (
|
|
// ie modal dialog fix
|
|
e.type == "focusin" ||
|
|
target.closest(this.element).length ||
|
|
target.closest(this.container).length ||
|
|
target.closest('.calendar-table').length
|
|
) return;
|
|
this.hide();
|
|
},
|
|
|
|
showCalendars: function() {
|
|
this.container.addClass('show-calendar');
|
|
this.move();
|
|
this.element.trigger('showCalendar.daterangepicker', this);
|
|
},
|
|
|
|
hideCalendars: function() {
|
|
this.container.removeClass('show-calendar');
|
|
this.element.trigger('hideCalendar.daterangepicker', this);
|
|
},
|
|
|
|
hoverRange: function(e) {
|
|
|
|
//ignore mouse movements while an above-calendar text input has focus
|
|
if (this.container.find('input[name=daterangepicker_start]').is(":focus") || this.container.find('input[name=daterangepicker_end]').is(":focus"))
|
|
return;
|
|
|
|
var label = e.target.innerHTML;
|
|
if (label == this.locale.customRangeLabel) {
|
|
this.updateView();
|
|
} else {
|
|
var dates = this.ranges[label];
|
|
this.container.find('input[name=daterangepicker_start]').val(dates[0].format(this.locale.format));
|
|
this.container.find('input[name=daterangepicker_end]').val(dates[1].format(this.locale.format));
|
|
}
|
|
|
|
},
|
|
|
|
clickRange: function(e) {
|
|
var label = e.target.innerHTML;
|
|
this.chosenLabel = label;
|
|
if (label == this.locale.customRangeLabel) {
|
|
this.showCalendars();
|
|
} else {
|
|
var dates = this.ranges[label];
|
|
this.startDate = dates[0];
|
|
this.endDate = dates[1];
|
|
|
|
if (!this.timePicker) {
|
|
this.startDate.startOf('day');
|
|
this.endDate.endOf('day');
|
|
}
|
|
|
|
this.hideCalendars();
|
|
this.clickApply();
|
|
}
|
|
},
|
|
|
|
clickPrev: function(e) {
|
|
var cal = $(e.target).parents('.calendar');
|
|
if (cal.hasClass('left')) {
|
|
this.leftCalendar.month.subtract(1, 'month');
|
|
if (this.linkedCalendars)
|
|
this.rightCalendar.month.subtract(1, 'month');
|
|
} else {
|
|
this.rightCalendar.month.subtract(1, 'month');
|
|
}
|
|
this.updateCalendars();
|
|
},
|
|
|
|
clickNext: function(e) {
|
|
var cal = $(e.target).parents('.calendar');
|
|
if (cal.hasClass('left')) {
|
|
this.leftCalendar.month.add(1, 'month');
|
|
} else {
|
|
this.rightCalendar.month.add(1, 'month');
|
|
if (this.linkedCalendars)
|
|
this.leftCalendar.month.add(1, 'month');
|
|
}
|
|
this.updateCalendars();
|
|
},
|
|
|
|
hoverDate: function(e) {
|
|
|
|
//ignore mouse movements while an above-calendar text input has focus
|
|
if (this.container.find('input[name=daterangepicker_start]').is(":focus") || this.container.find('input[name=daterangepicker_end]').is(":focus"))
|
|
return;
|
|
|
|
//ignore dates that can't be selected
|
|
if (!$(e.target).hasClass('available')) return;
|
|
|
|
//have the text inputs above calendars reflect the date being hovered over
|
|
var title = $(e.target).attr('data-title');
|
|
var row = title.substr(1, 1);
|
|
var col = title.substr(3, 1);
|
|
var cal = $(e.target).parents('.calendar');
|
|
var date = cal.hasClass('left') ? this.leftCalendar.calendar[row][col] : this.rightCalendar.calendar[row][col];
|
|
|
|
if (this.endDate) {
|
|
this.container.find('input[name=daterangepicker_start]').val(date.format(this.locale.format));
|
|
} else {
|
|
this.container.find('input[name=daterangepicker_end]').val(date.format(this.locale.format));
|
|
}
|
|
|
|
//highlight the dates between the start date and the date being hovered as a potential end date
|
|
var leftCalendar = this.leftCalendar;
|
|
var rightCalendar = this.rightCalendar;
|
|
var startDate = this.startDate;
|
|
if (!this.endDate) {
|
|
this.container.find('.calendar td').each(function(index, el) {
|
|
|
|
//skip week numbers, only look at dates
|
|
if ($(el).hasClass('week')) return;
|
|
|
|
var title = $(el).attr('data-title');
|
|
var row = title.substr(1, 1);
|
|
var col = title.substr(3, 1);
|
|
var cal = $(el).parents('.calendar');
|
|
var dt = cal.hasClass('left') ? leftCalendar.calendar[row][col] : rightCalendar.calendar[row][col];
|
|
|
|
if (dt.isAfter(startDate) && dt.isBefore(date)) {
|
|
$(el).addClass('in-range');
|
|
} else {
|
|
$(el).removeClass('in-range');
|
|
}
|
|
|
|
});
|
|
}
|
|
|
|
},
|
|
|
|
clickDate: function(e) {
|
|
|
|
if (!$(e.target).hasClass('available')) return;
|
|
|
|
var title = $(e.target).attr('data-title');
|
|
var row = title.substr(1, 1);
|
|
var col = title.substr(3, 1);
|
|
var cal = $(e.target).parents('.calendar');
|
|
var date = cal.hasClass('left') ? this.leftCalendar.calendar[row][col] : this.rightCalendar.calendar[row][col];
|
|
|
|
//
|
|
// this function needs to do a few things:
|
|
// * alternate between selecting a start and end date for the range,
|
|
// * if the time picker is enabled, apply the hour/minute/second from the select boxes to the clicked date
|
|
// * if autoapply is enabled, and an end date was chosen, apply the selection
|
|
// * if single date picker mode, and time picker isn't enabled, apply the selection immediately
|
|
//
|
|
|
|
if (this.endDate || date.isBefore(this.startDate)) {
|
|
if (this.timePicker) {
|
|
var hour = parseInt(this.container.find('.left .hourselect').val(), 10);
|
|
if (!this.timePicker24Hour) {
|
|
var ampm = cal.find('.ampmselect').val();
|
|
if (ampm === 'PM' && hour < 12)
|
|
hour += 12;
|
|
if (ampm === 'AM' && hour === 12)
|
|
hour = 0;
|
|
}
|
|
var minute = parseInt(this.container.find('.left .minuteselect').val(), 10);
|
|
var second = this.timePickerSeconds ? parseInt(this.container.find('.left .secondselect').val(), 10) : 0;
|
|
date = date.clone().hour(hour).minute(minute).second(second);
|
|
}
|
|
this.endDate = null;
|
|
this.setStartDate(date.clone());
|
|
} else {
|
|
if (this.timePicker) {
|
|
var hour = parseInt(this.container.find('.right .hourselect').val(), 10);
|
|
if (!this.timePicker24Hour) {
|
|
var ampm = this.container.find('.right .ampmselect').val();
|
|
if (ampm === 'PM' && hour < 12)
|
|
hour += 12;
|
|
if (ampm === 'AM' && hour === 12)
|
|
hour = 0;
|
|
}
|
|
var minute = parseInt(this.container.find('.right .minuteselect').val(), 10);
|
|
var second = this.timePickerSeconds ? parseInt(this.container.find('.right .secondselect').val(), 10) : 0;
|
|
date = date.clone().hour(hour).minute(minute).second(second);
|
|
}
|
|
this.setEndDate(date.clone());
|
|
if (this.autoApply)
|
|
this.clickApply();
|
|
}
|
|
|
|
if (this.singleDatePicker) {
|
|
this.setEndDate(this.startDate);
|
|
if (!this.timePicker)
|
|
this.clickApply();
|
|
}
|
|
|
|
this.updateView();
|
|
|
|
},
|
|
|
|
clickApply: function(e) {
|
|
this.hide();
|
|
this.element.trigger('apply.daterangepicker', this);
|
|
},
|
|
|
|
clickCancel: function(e) {
|
|
this.startDate = this.oldStartDate;
|
|
this.endDate = this.oldEndDate;
|
|
this.hide();
|
|
this.element.trigger('cancel.daterangepicker', this);
|
|
},
|
|
|
|
monthOrYearChanged: function(e) {
|
|
var isLeft = $(e.target).closest('.calendar').hasClass('left'),
|
|
leftOrRight = isLeft ? 'left' : 'right',
|
|
cal = this.container.find('.calendar.'+leftOrRight);
|
|
|
|
// Month must be Number for new moment versions
|
|
var month = parseInt(cal.find('.monthselect').val(), 10);
|
|
var year = cal.find('.yearselect').val();
|
|
|
|
if (!isLeft) {
|
|
if (year < this.startDate.year() || (year == this.startDate.year() && month < this.startDate.month())) {
|
|
month = this.startDate.month();
|
|
year = this.startDate.year();
|
|
}
|
|
}
|
|
|
|
if (this.minDate) {
|
|
if (year < this.minDate.year() || (year == this.minDate.year() && month < this.minDate.month())) {
|
|
month = this.minDate.month();
|
|
year = this.minDate.year();
|
|
}
|
|
}
|
|
|
|
if (this.maxDate) {
|
|
if (year > this.maxDate.year() || (year == this.maxDate.year() && month > this.maxDate.month())) {
|
|
month = this.maxDate.month();
|
|
year = this.maxDate.year();
|
|
}
|
|
}
|
|
|
|
if (isLeft) {
|
|
this.leftCalendar.month.month(month).year(year);
|
|
if (this.linkedCalendars)
|
|
this.rightCalendar.month = this.leftCalendar.month.clone().add(1, 'month');
|
|
} else {
|
|
this.rightCalendar.month.month(month).year(year);
|
|
if (this.linkedCalendars)
|
|
this.leftCalendar.month = this.rightCalendar.month.clone().subtract(1, 'month');
|
|
}
|
|
this.updateCalendars();
|
|
},
|
|
|
|
timeChanged: function(e) {
|
|
|
|
var cal = $(e.target).closest('.calendar'),
|
|
isLeft = cal.hasClass('left');
|
|
|
|
var hour = parseInt(cal.find('.hourselect').val(), 10);
|
|
var minute = parseInt(cal.find('.minuteselect').val(), 10);
|
|
var second = this.timePickerSeconds ? parseInt(cal.find('.secondselect').val(), 10) : 0;
|
|
|
|
if (!this.timePicker24Hour) {
|
|
var ampm = cal.find('.ampmselect').val();
|
|
if (ampm === 'PM' && hour < 12)
|
|
hour += 12;
|
|
if (ampm === 'AM' && hour === 12)
|
|
hour = 0;
|
|
}
|
|
|
|
if (isLeft) {
|
|
var start = this.startDate.clone();
|
|
start.hour(hour);
|
|
start.minute(minute);
|
|
start.second(second);
|
|
this.setStartDate(start);
|
|
if (this.singleDatePicker)
|
|
this.endDate = this.startDate.clone();
|
|
} else if (this.endDate) {
|
|
var end = this.endDate.clone();
|
|
end.hour(hour);
|
|
end.minute(minute);
|
|
end.second(second);
|
|
this.setEndDate(end);
|
|
}
|
|
|
|
//update the calendars so all clickable dates reflect the new time component
|
|
this.updateCalendars();
|
|
|
|
//update the form inputs above the calendars with the new time
|
|
this.updateFormInputs();
|
|
|
|
//re-render the time pickers because changing one selection can affect what's enabled in another
|
|
this.renderTimePicker('left');
|
|
this.renderTimePicker('right');
|
|
|
|
},
|
|
|
|
formInputsChanged: function(e) {
|
|
var isRight = $(e.target).closest('.calendar').hasClass('right');
|
|
var start = moment(this.container.find('input[name="daterangepicker_start"]').val(), this.locale.format).utcOffset(this.timeZone);
|
|
var end = moment(this.container.find('input[name="daterangepicker_end"]').val(), this.locale.format).utcOffset(this.timeZone);
|
|
|
|
if (start.isValid() && end.isValid()) {
|
|
|
|
if (isRight && end.isBefore(start))
|
|
start = end.clone();
|
|
|
|
this.setStartDate(start);
|
|
this.setEndDate(end);
|
|
|
|
if (isRight) {
|
|
this.container.find('input[name="daterangepicker_start"]').val(this.startDate.format(this.locale.format));
|
|
} else {
|
|
this.container.find('input[name="daterangepicker_end"]').val(this.endDate.format(this.locale.format));
|
|
}
|
|
|
|
}
|
|
|
|
this.updateCalendars();
|
|
if (this.timePicker) {
|
|
this.renderTimePicker('left');
|
|
this.renderTimePicker('right');
|
|
}
|
|
},
|
|
|
|
elementChanged: function() {
|
|
if (!this.element.is('input')) return;
|
|
if (!this.element.val().length) return;
|
|
|
|
var dateString = this.element.val().split(this.locale.separator),
|
|
start = null,
|
|
end = null;
|
|
|
|
if (dateString.length === 2) {
|
|
start = moment(dateString[0], this.locale.format).utcOffset(this.timeZone);
|
|
end = moment(dateString[1], this.locale.format).utcOffset(this.timeZone);
|
|
}
|
|
|
|
if (this.singleDatePicker || start === null || end === null) {
|
|
start = moment(this.element.val(), this.locale.format).utcOffset(this.timeZone);
|
|
end = start;
|
|
}
|
|
|
|
this.setStartDate(start);
|
|
this.setEndDate(end);
|
|
this.updateView();
|
|
},
|
|
|
|
keydown: function(e) {
|
|
//hide on tab or enter
|
|
if ((e.keyCode === 9) || (e.keyCode === 13)) {
|
|
this.hide();
|
|
}
|
|
},
|
|
|
|
updateElement: function() {
|
|
if (this.element.is('input') && !this.singleDatePicker && this.autoUpdateInput) {
|
|
this.element.val(this.startDate.format(this.locale.format) + this.locale.separator + this.endDate.format(this.locale.format));
|
|
this.element.trigger('change');
|
|
} else if (this.element.is('input') && this.autoUpdateInput) {
|
|
this.element.val(this.startDate.format(this.locale.format));
|
|
this.element.trigger('change');
|
|
}
|
|
},
|
|
|
|
remove: function() {
|
|
this.container.remove();
|
|
this.element.off('.daterangepicker');
|
|
this.element.removeData();
|
|
}
|
|
|
|
};
|
|
|
|
$.fn.daterangepicker = function(options, callback) {
|
|
this.each(function() {
|
|
var el = $(this);
|
|
if (el.data('daterangepicker'))
|
|
el.data('daterangepicker').remove();
|
|
el.data('daterangepicker', new DateRangePicker(el, options, callback));
|
|
});
|
|
return this;
|
|
};
|
|
|
|
})); |