@progress/kendo-ui
Version:
This package is part of the [Kendo UI for jQuery](http://www.telerik.com/kendo-ui) suite.
1,363 lines (1,164 loc) • 214 kB
JavaScript
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
require('./kendo.dropdownlist.js');
require('./kendo.editable.js');
require('./kendo.multiselect.js');
require('./kendo.window.js');
require('./kendo.datetimepicker.js');
require('./kendo.scheduler.recurrence.js');
require('./kendo.scheduler.view.js');
require('./kendo.scheduler.dayview.js');
require('./kendo.scheduler.agendaview.js');
require('./kendo.scheduler.monthview.js');
require('./kendo.scheduler.timelineview.js');
require('./kendo.scheduler.yearview.js');
require('./kendo.dialog.js');
require('./kendo.pane.js');
require('./kendo.core.js');
require('./html-sdnHcjkh.js');
require('./mixins-D385O08Q.js');
require('./kendo.switch.js');
require('./kendo.toolbar.js');
require('./kendo.html.button.js');
require('./kendo.icons.js');
require('./kendo.list.js');
require('./kendo.data.js');
require('./kendo.data.odata.js');
require('./kendo.licensing.js');
require('@progress/kendo-licensing');
require('./kendo.data.xml.js');
require('./kendo.popup.js');
require('./kendo.label.js');
require('./kendo.floatinglabel.js');
require('./kendo.actionsheet.js');
require('./kendo.html.icon.js');
require('./kendo.html.base.js');
require('@progress/kendo-svg-icons');
require('./dropdowns-loader-Bc4IELFi.js');
require('./kendo.mobile.scroller.js');
require('./kendo.fx.js');
require('./kendo.draganddrop.js');
require('./kendo.userevents.js');
require('./kendo.virtuallist.js');
require('./valueMapper-q_OtZ-Tj.js');
require('./kendo.checkbox.js');
require('./kendo.toggleinputbase.js');
require('./kendo.html.input.js');
require('./kendo.datepicker.js');
require('./kendo.calendar.js');
require('./kendo.selectable.js');
require('./kendo.dateinput.js');
require('@progress/kendo-dateinputs-common');
require('./kendo.numerictextbox.js');
require('./prefix-suffix-containers-BmDm564f.js');
require('./kendo.textbox.js');
require('./kendo.validator.js');
require('./kendo.binder.js');
require('./kendo.otpinput.js');
require('./kendo.html.chip.js');
require('./kendo.html.chiplist.js');
require('./kendo.timepicker.js');
require('./kendo.buttongroup.js');
require('./kendo.togglebutton.js');
require('./kendo.button.js');
require('./kendo.badge.js');
require('./kendo.splitbutton.js');
require('./kendo.button.menu.js');
require('./kendo.dropdownbutton.js');
require('./kendo.menu.js');
require('./kendo.multiviewcalendar.js');
require('./kendo.tooltip.js');
require('./kendo.view.js');
require('@progress/kendo-drawing');
require('./kendo.color.js');
const __meta__ = {
id: "scheduler",
name: "Scheduler",
category: "web",
description: "The Scheduler is an event calendar.",
depends: [ "dropdownlist", "editable", "multiselect", "window", "datepicker", "datetimepicker", "toolbar", "scheduler.recurrence", "scheduler.view", "html.button", "icons" ],
features: [ {
id: "scheduler-dayview",
name: "Scheduler Day View",
description: "Scheduler Day View",
depends: [ "scheduler.dayview" ]
}, {
id: "scheduler-agendaview",
name: "Scheduler Agenda View",
description: "Scheduler Agenda View",
depends: [ "scheduler.agendaview" ]
}, {
id: "scheduler-monthview",
name: "Scheduler Month View",
description: "Scheduler Month View",
depends: [ "scheduler.monthview" ]
}, {
id: "scheduler-timelineview",
name: "Scheduler Timeline View",
description: "Scheduler Timeline View",
depends: [ "scheduler.timelineview" ]
}, {
id: "scheduler-yearview",
name: "Scheduler Year View",
description: "Scheduler Year View",
depends: [ "scheduler.yearview" ]
}, {
id: "scheduler-mobile",
name: "Scheduler adaptive rendering",
description: "Support for adaptive rendering",
depends: [ "dialog", "pane", "switch" ]
}, {
id: "scheduler-pdf-export",
name: "PDF export",
description: "Export the scheduler events as PDF",
depends: [ "pdf", "drawing" ]
}, {
id: "scheduler-timezones",
name: "Timezones",
description: "Allow selecting timezones different than Etc/UTC",
depends: [ "timezones" ]
}]
};
(function($, undefined$1) {
var kendo = window.kendo,
date = kendo.date,
MS_PER_DAY = date.MS_PER_DAY,
getDate = date.getDate,
getMilliseconds = kendo.date.getMilliseconds,
recurrence = kendo.recurrence,
encode = kendo.htmlEncode,
keys = kendo.keys,
ui = kendo.ui,
Widget = ui.Widget,
DataBoundWidget = ui.DataBoundWidget,
STRING = "string",
Popup = ui.Popup,
Calendar = ui.Calendar,
DataSource = kendo.data.DataSource,
isPlainObject = $.isPlainObject,
extend = $.extend,
toString = Object.prototype.toString,
isArray = Array.isArray,
NS = ".kendoScheduler",
CLICK = "click",
MOUSEDOWN = "mousedown",
TOUCHSTART = kendo.support.pointers ? "pointerdown" : "touchstart",
TOUCHMOVE = kendo.support.pointers ? "pointermove" : "touchmove",
TOUCHEND = kendo.support.pointers ? "pointerup" : "touchend",
MOUSEMOVE = kendo.support.mousemove,
CHANGE = "change",
PROGRESS = "progress",
ERROR = "error",
CANCEL = "cancel",
REMOVE = "remove",
RESET = "resetSeries",
SAVE = "save",
ADD = "add",
EDIT = "edit",
DISABLED = "disabled",
OPTION = "option",
FOCUSEDSTATE = "k-focus",
INVERSECOLORCLASS = "k-event-inverse",
valueStartEndBoundRegex = /(?:value:start|value:end)(?:,|$)/,
MIN_SCREEN = "(min-width: 1024px)",
TODAY = getDate(new Date()),
EXCEPTION_SEPARATOR = ",",
OLD_EXCEPTION_SEPARATOR_REGEXP = /\;/g,
RECURRENCE_EXCEPTION = "recurrenceException",
DELETECONFIRM = "Are you sure you want to delete this event?",
DELETERECURRING = "Do you want to delete only this event occurrence or the whole series?",
EDITRECURRING = "Do you want to edit only this event occurrence or the whole series?",
DELETERECURRINGCONFIRM = "Are you sure you want to delete this event occurrence?",
RESETSERIESCONFIRM = "Are you sure you want to reset the whole series?",
DELETESERIESCONFIRM = "Are you sure you want to delete the whole series?",
ONGOING_CLASS = "k-event-ongoing",
COMMANDBUTTONTMPL = ({ className, attr, text, icon, fillMode, themeColor }) =>
kendo.html.renderButton(`<button type="button" class="${className}" ${attr}>${text}</button>`, {
icon: icon,
fillMode: fillMode,
themeColor: themeColor
}),
VIEWS_DROPDOWN_TEMPLATE = kendo.template(({ label, views, type }) =>
`<select aria-label="${label}" class="k-picker k-dropdown-list k-dropdown ${type}">` +
Object.keys(views).map((view) => `<option value="${view}">${views[view].title}</option>`).join('') +
'</select>'
),
DEFAULT_TOOLS = {
pdf: {
name: "pdf",
type: "button",
icon: "file-pdf",
attributes: {
class: "k-pdf"
}
},
pdfMobile: {
name: "pdf",
type: "button",
icon: "file-pdf",
showText: "overflow",
attributes: {
class: "k-pdf"
}
},
today: {
name: "today",
type: "button",
attributes: {
"ref-nav-today": "",
}
},
previous: {
name: "previous",
type: "button",
icon: "caret-alt-left",
showText: "overflow",
attributes: {
"ref-nav-prev": "",
},
groupClass: "k-scheduler-navigation"
},
next: {
name: "next",
type: "button",
icon: "caret-alt-right",
showText: "overflow",
attributes: {
"ref-nav-next": "",
},
groupClass: "k-scheduler-navigation"
},
current: {
name: "current",
type: "button",
icon: "calendar",
fillMode: "flat",
text: 'placeholder',
attributes: {
"aria-live": "polite",
class: "k-nav-current"
}
},
search: {
template: '<span class="k-scheduler-search k-textbox k-input k-input-md k-rounded-md k-input-solid">' +
'<input tabindex="-1" autocomplete="off" class="k-input-inner k-scheduler-search-input k-input-inner" />' +
`<span class="k-input-suffix">${kendo.ui.icon("search")}</span>` +
'</span>'
},
refresh: {
name: "refresh",
type: "button",
icon: "arrow-rotate-cw",
showText: "overflow",
attributes: {
class: "k-scheduler-refresh"
}
},
create: {
name: "create",
type: "button",
icon: "plus",
attributes: {
class: "k-create-event"
}
},
calendar: {
name: "calendar",
type: "button",
icon: "calendar",
attributes: {
class: "k-nav-calendar"
}
},
previousMobile: {
name: "previous",
type: "button",
icon: "chevron-left",
showText: "overflow",
attributes: {
"ref-nav-prev": "",
},
groupClass: "k-scheduler-navigation"
},
nextMobile: {
name: "next",
type: "button",
icon: "chevron-right",
showText: "overflow",
attributes: {
"ref-nav-next": "",
},
groupClass: "k-scheduler-navigation"
},
currentMobile: {
template: '<span class="k-scheduler-navigation">' +
'<span class="k-nav-current">' +
'<span class="k-m-date-format"></span>' +
'<span class="k-y-date-format"></span>' +
'</span>' +
'</span>'
},
view: {
name: "view",
type: "button",
togglable: true,
group: "views"
}
},
defaultDesktopTools = [
["today", "previous", "next"],
"current",
{ type: "spacer" }
],
defaultMobileToolsFirst = [
["calendar"],
{ type: "spacer" }
],
defaultMobileToolsSecond = [
"previousMobile",
{ type: "spacer" },
"currentMobile",
{ type: "spacer" },
"nextMobile"
],
MOBILEDATERANGEEDITOR = function(container, options) {
var attr = { name: options.field, title: options.title };
var isAllDay = options.model.isAllDay;
var dateTimeValidate = kendo.attr("validate") + "='" + (!isAllDay) + "'";
var dateValidate = kendo.attr("validate") + "='" + (!!isAllDay) + "'";
appendTimezoneAttr(attr, options);
appendValidDateValidator(attr, options);
appendDateCompareValidator(attr, options);
$('<input type="datetime-local" required ' + kendo.attr("type") + '="datetime-local" ' + kendo.attr("bind") + '="value:' + options.field + ', invisible:isAllDay" ' + dateTimeValidate + '/>')
.attr(attr)
.appendTo(container);
$('<input type="date" required ' + kendo.attr("type") + '="date" ' + kendo.attr("bind") + '="value:' + options.field + ',visible:isAllDay" ' +
dateValidate + '/>')
.attr(attr).appendTo(container);
$('<span ' + kendo.attr("for") + '="' + options.field + '" class="k-invalid-msg"/>').hide().appendTo(container);
},
DATERANGEEDITOR = function(container, options) {
var attr = { name: options.field, title: options.title },
isAllDay = options.model.isAllDay,
dateTimeValidate = kendo.attr("validate") + "='" + (!isAllDay) + "' ",
dateValidate = kendo.attr("validate") + "='" + (!!isAllDay) + "' ";
appendTimezoneAttr(attr, options);
appendValidDateValidator(attr, options);
appendDateCompareValidator(attr, options);
$('<input type="text" required ' + kendo.attr("type") + '="date"' + ' ' + kendo.attr("role") + '="datetimepicker" ' + kendo.attr("bind") + '="value:' + options.field + ',invisible:isAllDay" ' +
dateTimeValidate + '/>')
.attr(attr).appendTo(container);
$('<input type="text" required ' + kendo.attr("type") + '="date"' + ' ' + kendo.attr("role") + '="datepicker" ' + kendo.attr("bind") + '="value:' + options.field + ',visible:isAllDay" ' +
dateValidate + '/>')
.attr(attr).appendTo(container);
$('<span ' + kendo.attr("bind") + '="text: ' + options.field + 'Timezone"></span>').appendTo(container);
if (options.field === "end") {
$('<span ' + kendo.attr("bind") + '="text: startTimezone, invisible: endTimezone"></span>').appendTo(container);
}
$('<span ' + kendo.attr("for") + '="' + options.field + '" class="k-invalid-msg"/>').hide().appendTo(container);
},
RECURRENCEEDITOR = function(container, options) {
$('<div ' + kendo.attr("bind") + '="value:' + options.field + '" />')
.attr({
name: options.field
})
.appendTo(container)
.kendoRecurrenceEditor({
start: options.model.start,
timezone: options.timezone,
messages: options.messages
});
},
MOBILERECURRENCEEDITOR = function(container, options) {
$('<div ' + kendo.attr("bind") + '="value:' + options.field + '" />')
.attr({
name: options.field
})
.appendTo(container)
.kendoMobileRecurrenceEditor({
start: options.model.start,
timezone: options.timezone,
messages: options.messages,
pane: options.pane,
value: options.model[options.field]
});
},
MOBILEISALLDAYEDITOR = function(container, options) {
$('<input type="checkbox" data-role="switch"' + kendo.attr("bind") + '="value:' + options.field + '" />').appendTo(container);
},
ISALLDAYEDITOR = function(container, options) {
$('<input type="checkbox" data-role="checkbox"' + kendo.attr("bind") + '="value:' + options.field + '" data-label="' + options.title + '" />')
.attr({
id: options.field,
name: options.field,
title: options.title ? options.title : options.field
})
.appendTo(container);
},
MOBILETIMEZONEPOPUP = function(container, options) {
var text = timezoneButtonText(options.model, options.messages.noTimezone);
$('<span class="k-timezone-label"></span>').text(text).appendTo(container);
$(kendo.ui.icon("arrow-chevron-right")).appendTo(container);
container.closest("li.k-item label").on(CLICK, options.click);
},
TIMEZONEPOPUP = function(container, options) {
$('<a href="#" class="k-button k-button-md k-rounded-md k-button-solid k-button-solid-base" data-bind="invisible:isAllDay"><span class="k-button-text">' + options.messages.timezoneEditorButton + '</span></a>').on(CLICK, options.click).appendTo(container);
},
MOBILETIMEZONEEDITOR = function(container, options) {
$('<div class="k-mobiletimezoneeditor" ' + kendo.attr("bind") + '="value:' + options.field + '" />')
.attr({
name: options.field
})
.appendTo(container)
.kendoMobileTimezoneEditor({
optionLabel: options.noTimezone
});
},
TIMEZONEEDITOR = function(container, options) {
var visible = options.visible || options.visible === undefined$1;
$('<div ' + kendo.attr("bind") + '="value:' + options.field + '" />')
.attr({ name: options.field })
.toggle(visible)
.appendTo(container)
.kendoTimezoneEditor({
optionLabel: options.noTimezone,
title: options.title
});
};
function timezoneButtonText(model, message) {
message = message || "";
if (model.startTimezone) {
message = model.startTimezone;
if (model.endTimezone) {
message += " | " + model.endTimezone;
}
}
return message;
}
function appendTimezoneAttr(attrs, options) {
var timezone = options.timezone;
if (timezone) {
attrs[kendo.attr("timezone")] = timezone;
}
}
function appendValidDateValidator(attrs, options) {
var validationRules = options.model.fields[options.field].validation;
if (validationRules) {
var validDateRule = validationRules.validDateValidator;
if (validDateRule && isPlainObject(validDateRule) && validDateRule.message) {
attrs[kendo.attr("validDate-msg")] = validDateRule.message;
}
}
}
function appendDateCompareValidator(attrs, options) {
var validationRules = options.model.fields[options.field].validation;
if (validationRules) {
var dateCompareRule = validationRules.dateCompare;
if (dateCompareRule && isPlainObject(dateCompareRule) && dateCompareRule.message) {
attrs[kendo.attr("dateCompare-msg")] = dateCompareRule.message;
}
}
}
function wrapDataAccess(originalFunction, timezone) {
return function(data) {
data = originalFunction(data);
convertData(data, "apply", timezone);
return data || [];
};
}
function wrapDataSerialization(originalFunction, timezone) {
return function(data) {
if (data) {
if (toString.call(data) !== "[object Array]" && !(data instanceof kendo.data.ObservableArray)) {
data = [data];
}
}
convertData(data, "remove", timezone, true);
data = originalFunction(data);
return data || [];
};
}
function convertData(data, method, timezone, removeUid) {
var event,
idx,
length,
startOffset,
endOffset;
data = data || [];
for (idx = 0, length = data.length; idx < length; idx++) {
event = data[idx];
startOffset = event.start ? event.start.getTimezoneOffset() : null;
endOffset = event.start ? event.end.getTimezoneOffset() : null;
if (removeUid) {
if (event.startTimezone || event.endTimezone) {
if (timezone) {
event.start = kendo.timezone.convert(event.start, event.startTimezone || event.endTimezone, timezone);
event.end = kendo.timezone.convert(event.end, event.endTimezone || event.startTimezone, timezone);
event.start = kendo.timezone[method](event.start, timezone);
event.end = kendo.timezone[method](event.end, timezone);
} else {
event.start = kendo.timezone[method](event.start, event.startTimezone || event.endTimezone);
event.end = kendo.timezone[method](event.end, event.endTimezone || event.startTimezone);
}
} else if (timezone) {
event.start = kendo.timezone[method](event.start, timezone);
event.end = kendo.timezone[method](event.end, timezone);
}
} else {
if (event.startTimezone || event.endTimezone) {
event.start = kendo.timezone[method](event.start, event.startTimezone || event.endTimezone);
event.end = kendo.timezone[method](event.end, event.endTimezone || event.startTimezone);
if (timezone) {
event.start = kendo.timezone.convert(event.start, event.startTimezone || event.endTimezone, timezone);
event.end = kendo.timezone.convert(event.end, event.endTimezone || event.startTimezone, timezone);
}
} else if (timezone) {
event.start = kendo.timezone[method](event.start, timezone);
event.end = kendo.timezone[method](event.end, timezone);
}
}
if (removeUid) {
delete event.uid;
}
if (method === "remove" && event.start && startOffset && startOffset !== event.start.getTimezoneOffset()) {
event.start = new Date(event.start.getTime() + (startOffset - event.start.getTimezoneOffset()) * 60000);
}
if (method === "remove" && event.end && endOffset && endOffset !== event.end.getTimezoneOffset()) {
event.end = new Date(event.end.getTime() + (endOffset - event.end.getTimezoneOffset()) * 60000);
}
}
return data;
}
function getOccurrenceByUid(data, uid) {
var length = data.length,
idx = 0,
event;
for (; idx < length; idx++) {
event = data[idx];
if (event.uid === uid) {
return event;
}
}
}
var SchedulerDataReader = kendo.Class.extend({
init: function(schema, reader) {
var timezone = schema.timezone;
this.reader = reader;
if (reader.model) {
this.model = reader.model;
}
this.timezone = timezone;
this.data = wrapDataAccess(this.data.bind(this), timezone);
this.serialize = wrapDataSerialization(this.serialize.bind(this), timezone);
},
errors: function(data) {
return this.reader.errors(data);
},
parse: function(data) {
return this.reader.parse(data);
},
data: function(data) {
return this.reader.data(data);
},
total: function(data) {
return this.reader.total(data);
},
groups: function(data) {
return this.reader.groups(data);
},
aggregates: function(data) {
return this.reader.aggregates(data);
},
serialize: function(data) {
return this.reader.serialize(data);
}
});
function applyZone(date, fromZone, toZone) {
if (toZone) {
date = kendo.timezone.convert(date, fromZone, toZone);
} else {
date = kendo.timezone.remove(date, fromZone);
}
return date;
}
function validDateValidator(input) {
if ((input.filter("[name=start]").length && input.filter("[title=Start]").length) ||
(input.filter("[name=end]").length && input.filter("[title=End]").length) ||
input.filter(".k-recur-until").length) {
var date;
var picker = kendo.widgetInstance(input, kendo.ui);
if (picker) {
date = kendo.parseDate(input.val(), picker.options.format);
return !!date && picker.value();
} else {
date = kendo.parseDate(input.val());
return !!date;
}
}
return true;
}
function dateCompareValidator(input) {
if (input.filter("[name=end]").length) {
var container = input.closest(".k-scheduler-edit-form");
var startInput = container.find("[name=start]:visible");
var endInput = container.find("[name=end]:visible");
if (endInput[0] && startInput[0]) {
var start, end;
var startPicker = kendo.widgetInstance(startInput, kendo.ui);
var endPicker = kendo.widgetInstance(endInput, kendo.ui);
var editable = container.data("kendoEditable");
var model = editable ? editable.options.model : null;
if (startPicker && endPicker) {
start = startPicker.value();
end = endPicker.value();
} else {
start = kendo.parseDate(startInput.val());
end = kendo.parseDate(endInput.val());
}
if (start && end) {
if (model) {
var timezone = startInput.attr(kendo.attr("timezone"));
var startTimezone = model.startTimezone;
var endTimezone = model.endTimezone;
startTimezone = startTimezone || endTimezone;
endTimezone = endTimezone || startTimezone;
if (startTimezone) {
start = applyZone(start, startTimezone, timezone);
end = applyZone(end, endTimezone, timezone);
}
}
return start <= end;
}
}
}
return true;
}
function untilDateCompareValidator(input) {
var untilPicker, until,
container, startInput, start, startPicker;
if (input.filter(".k-recur-until").length) {
untilPicker = kendo.widgetInstance(input, kendo.ui);
until = untilPicker.value();
container = input.closest(".k-scheduler-edit-form");
startInput = container.find("[name=start]:visible");
if (startInput[0]) {
startPicker = kendo.widgetInstance(startInput, kendo.ui);
if (startPicker) {
start = startPicker.value();
} else {
start = kendo.parseDate(startInput.val());
}
if (start && until) {
return start <= until;
}
}
}
return true;
}
var SchedulerEvent = kendo.data.Model.define({
init: function(value) {
var that = this;
kendo.data.Model.fn.init.call(that, value);
that._defaultId = that.defaults[that.idField];
},
_time: function(field) {
var date = this[field];
var fieldTime = "_" + field + "Time";
if (this[fieldTime]) {
return this[fieldTime] - kendo.date.toUtcTime(kendo.date.getDate(date));
}
return getMilliseconds(date);
},
_date: function(field) {
var fieldTime = "_" + field + "Time";
if (this[fieldTime]) {
return this[fieldTime] - this._time(field);
}
return kendo.date.getDate(this[field]);
},
clone: function(options, updateUid) {
var uid = this.uid,
event = new this.constructor($.extend({}, this.toJSON(), options));
if (!updateUid) {
event.uid = uid;
}
return event;
},
duration: function() {
var end = this.end;
var start = this.start;
var offset = (end.getTimezoneOffset() - start.getTimezoneOffset()) * kendo.date.MS_PER_MINUTE;
return end - start - offset;
},
expand: function(start, end, zone) {
return recurrence ? recurrence.expand(this, start, end, zone) : [this];
},
update: function(eventInfo) {
for (var field in eventInfo) {
this.set(field, eventInfo[field]);
}
if (this._startTime) {
this.set("_startTime", kendo.date.toUtcTime(this.start));
}
if (this._endTime) {
this.set("_endTime", kendo.date.toUtcTime(this.end));
}
},
isMultiDay: function() {
return this.isAllDay || this.duration() >= kendo.date.MS_PER_DAY;
},
isException: function() {
return !this.isNew() && this.recurrenceId;
},
isOccurrence: function() {
return this.isNew() && this.recurrenceId;
},
isRecurring: function() {
return !!(this.recurrenceRule || this.recurrenceId);
},
isRecurrenceHead: function() {
return !!(this.id && this.recurrenceRule);
},
toOccurrence: function(options) {
options = $.extend(options, {
recurrenceException: null,
recurrenceRule: null,
recurrenceId: this.id || this.recurrenceId
});
options[this.idField] = this.defaults[this.idField];
return this.clone(options, true);
},
toJSON: function() {
var obj = kendo.data.Model.fn.toJSON.call(this);
obj.uid = this.uid;
delete obj._startTime;
delete obj._endTime;
return obj;
},
shouldSerialize: function(field) {
return kendo.data.Model.fn.shouldSerialize.call(this, field) && field !== "_defaultId";
},
set: function(key, value) {
var isAllDay = this.isAllDay || false;
kendo.data.Model.fn.set.call(this, key, value);
if (key == "isAllDay" && value != isAllDay) {
var start = kendo.date.getDate(this.start);
var end = new Date(this.end);
var milliseconds = kendo.date.getMilliseconds(end);
if (milliseconds === 0 && value) {
milliseconds = MS_PER_DAY;
}
this.set("start", start);
if (value === true) {
kendo.date.setTime(end, -milliseconds);
if (end < start) {
end = start;
}
} else {
kendo.date.setTime(end, MS_PER_DAY - milliseconds);
}
this.set("end", end);
}
},
id: "id",
fields: {
id: { type: "number" },
title: { defaultValue: "", type: "string" },
start: { type: "date", validation: { required: true, validDate: { value: validDateValidator } } },
startTimezone: { type: "string" },
end: {
type: "date",
validation: {
required: true,
validDate: { value: validDateValidator },
dateCompare: { value: dateCompareValidator }
}
},
endTimezone: { type: "string" },
recurrenceRule: {
defaultValue: "",
type: "string",
validation: {
validDate: { value: validDateValidator },
untilDateCompare: { value: untilDateCompareValidator }
}
},
recurrenceException: { defaultValue: "", type: "string" },
isAllDay: { type: "boolean", defaultValue: false },
description: { type: "string" }
}
});
var SchedulerDataSource = DataSource.extend({
init: function(options) {
DataSource.fn.init.call(this, extend(true, {}, {
schema: {
modelBase: SchedulerEvent,
model: SchedulerEvent
}
}, options));
this.reader = new SchedulerDataReader(this.options.schema, this.reader);
},
expand: function(start, end) {
var data = this.view(),
filter = {},
endOffset;
if (start && end) {
endOffset = end.getTimezoneOffset();
end = new Date(end.getTime() + MS_PER_DAY - 1);
if (end.getTimezoneOffset() !== endOffset) {
end = kendo.timezone.apply(end, endOffset);
}
filter = {
logic: "or",
filters: [
{
logic: "and",
filters: [
{ field: "start", operator: "gte", value: start },
{ field: "end", operator: "gte", value: start },
{ field: "start", operator: "lte", value: end }
]
},
{
logic: "and",
filters: [
{ field: "start", operator: "lte", value: new Date(start.getTime() + MS_PER_DAY - 1) },
{ field: "end", operator: "gte", value: start }
]
}
]
};
data = new kendo.data.Query(expandAll(data, start, end, this.reader.timezone)).filter(filter).toArray();
}
return data;
},
cancelChanges: function(model) {
if (model && model.isOccurrence()) {
this._removeExceptionDate(model);
}
DataSource.fn.cancelChanges.call(this, model);
},
insert: function(index, model) {
if (!model) {
return;
}
if (!(model instanceof SchedulerEvent)) {
var eventInfo = model;
model = this._createNewModel();
model.accept(eventInfo);
}
if ((!this._pushCreated && model.isRecurrenceHead()) || model.recurrenceId) {
model = model.recurrenceId ? model : model.toOccurrence();
this._addExceptionDate(model);
}
return DataSource.fn.insert.call(this, index, model);
},
pushCreate: function(items) {
this._pushCreated = true;
DataSource.fn.pushCreate.call(this, items);
this._pushCreated = false;
},
remove: function(model) {
if (model.isRecurrenceHead()) {
this._removeExceptions(model);
} else if (model.isRecurring()) {
this._addExceptionDate(model);
}
return DataSource.fn.remove.call(this, model);
},
_removeExceptions: function(model) {
var data = this.data().slice(0),
item = data.shift(),
id = model.id;
while (item) {
if (item.recurrenceId === id) {
DataSource.fn.remove.call(this, item);
}
item = data.shift();
}
model.set(RECURRENCE_EXCEPTION, "");
},
_removeExceptionDate: function(model) {
if (model.recurrenceId) {
var head = this.get(model.recurrenceId);
if (head) {
var start = model.defaults.start;
var replaceRegExp = new RegExp("(\\" + EXCEPTION_SEPARATOR + "?)" + recurrence.toExceptionString(start, this.reader.timezone));
var recurrenceException = (head.recurrenceException || "").replace(OLD_EXCEPTION_SEPARATOR_REGEXP, EXCEPTION_SEPARATOR).replace(/\,$/, "");
if (replaceRegExp.test(recurrenceException)) {
head.set(RECURRENCE_EXCEPTION, recurrenceException.replace(replaceRegExp, ""));
} else {
start = model.start;
replaceRegExp = new RegExp("(\\" + EXCEPTION_SEPARATOR + "?)" + recurrence.toExceptionString(start, this.reader.timezone));
head.set(RECURRENCE_EXCEPTION, recurrenceException.replace(replaceRegExp, ""));
}
}
}
},
_addExceptionDate: function(model) {
var start = model.start;
var zone = this.reader.timezone;
var head = this.get(model.recurrenceId);
var recurrenceException = (head.recurrenceException || "").replace(OLD_EXCEPTION_SEPARATOR_REGEXP, EXCEPTION_SEPARATOR).replace(/\,$/, "");
if (!recurrence.isException(recurrenceException, start, zone)) {
var newException = recurrence.toExceptionString(start, zone);
model.defaults.start = start;
head.set(RECURRENCE_EXCEPTION, recurrenceException + (recurrenceException && newException ? EXCEPTION_SEPARATOR : "") + newException);
}
}
});
function expandAll(events, start, end, zone) {
var length = events.length,
data = [],
idx = 0;
for (; idx < length; idx++) {
data = data.concat(events[idx].expand(start, end, zone));
}
return data;
}
SchedulerDataSource.create = function(options) {
if (isArray(options) || options instanceof kendo.data.ObservableArray) {
options = { data: options };
}
var dataSource = options || {},
data = dataSource.data;
dataSource.data = data;
if (!(dataSource instanceof SchedulerDataSource) && dataSource instanceof kendo.data.DataSource) {
throw new Error("Incorrect DataSource type. Only SchedulerDataSource instances are supported");
}
return dataSource instanceof SchedulerDataSource ? dataSource : new SchedulerDataSource(dataSource);
};
extend(true, kendo.data, {
SchedulerDataSource: SchedulerDataSource,
SchedulerDataReader: SchedulerDataReader,
SchedulerEvent: SchedulerEvent
});
var defaultCommands = {
update: {
text: "Save",
className: "k-button-solid-primary k-scheduler-update"
},
canceledit: {
text: "Cancel",
className: "k-scheduler-cancel"
},
destroy: {
text: "Delete",
icon: "trash",
imageClass: "k-i-trash",
className: "k-button-solid-primary k-scheduler-delete",
iconClass: "k-icon"
}
};
function trimOptions(options, overrideOptions) {
delete options.name;
delete options.prefix;
delete options.remove;
delete options.edit;
delete options.add;
delete options.navigate;
for (var key in overrideOptions) {
options[key] = overrideOptions[key];
}
return options;
}
/*
function fieldType(field) {
field = field != null ? field : "";
return field.type || kendo.type(field) || "string";
}
*/
function descriptionEditor(options) {
var attr = createValidationAttributes(options.model, options.field);
return function(container, model) {
$('<textarea name="description" class="k-input-inner" title="' + model.title + '"/>').attr(attr)
.appendTo(container)
.wrap('<span class="k-input k-textarea k-input-solid k-input-md k-rounded-md"></span>');
};
}
function createValidationAttributes(model, field) {
var modelField = (model.fields || model)[field];
var specialRules = ["url", "email", "number", "date", "boolean"];
var validation = modelField ? modelField.validation : {};
// var type = fieldType(modelField);
var datatype = kendo.attr("type");
var inArray = $.inArray;
var ruleName;
var rule;
var attr = {};
for (ruleName in validation) {
rule = validation[ruleName];
if (inArray(ruleName, specialRules) >= 0) {
attr[datatype] = ruleName;
} else if (!kendo.isFunction(rule)) {
attr[ruleName] = isPlainObject(rule) ? (rule.value || ruleName) : rule;
}
attr[kendo.attr(ruleName + "-msg")] = rule.message;
}
return attr;
}
function filterResourceEditorData(editor, parentValue, parentValueField, valueField) {
var editorValue = editor.value(),
isMs = Array.isArray(editorValue),
valueArray;
if (isMs) {
valueArray = JSON.parse(JSON.stringify(editorValue));
} else {
valueArray = [editorValue.toString()];
}
editor.dataSource.data().forEach(function(item) {
if (item[parentValueField] === null || item[parentValueField] === undefined$1 || item[parentValueField] == parentValue) {
item.set(DISABLED, false);
} else {
var currentValue = item.get(valueField);
item.set(DISABLED, true);
if (valueArray.indexOf(currentValue) >= 0 || valueArray.indexOf(currentValue.toString()) >= 0) {
if (isMs) {
valueArray.splice(valueArray.indexOf(currentValue), 1);
} else {
editor.value(null);
editor.trigger(CHANGE);
}
}
}
});
if (isMs && valueArray.length < editorValue.length) {
editor.value(valueArray);
editor.trigger(CHANGE);
}
}
function bindParentValueChangeHandler(container, currentEditor, resource, parent) {
var parentElement = container.closest(".k-edit-form-container").find("[data-" + kendo.ns + "bind='value:" + parent + "']");
var parentWidget = parentElement.getKendoDropDownList();
if (parentWidget) {
parentWidget.bind(CHANGE, function(ev) {
var parentValue = ev.sender.value();
filterResourceEditorData(currentEditor, parentValue, resource.dataParentValueField, resource.dataValueField);
});
} else {
parentElement.on(CHANGE, function(ev) {
var parentValue = ev.target.value;
filterResourceEditorData(currentEditor, parentValue, resource.dataParentValueField, resource.dataValueField);
});
}
}
function filterMobileResourceEditorData(resource, currentEditor, parentSelectedValue) {
var options = currentEditor.find(OPTION),
editorValue = currentEditor.val(),
isMs = Array.isArray(editorValue),
valueArray;
if (isMs) {
valueArray = JSON.parse(JSON.stringify(editorValue));
} else {
valueArray = [editorValue];
}
resource.dataSource.view().forEach(function(item, index) {
var itemParentValue = kendo.getter(resource.dataParentValueField)(item);
var valid = itemParentValue === null || itemParentValue === undefined$1 || itemParentValue == parentSelectedValue;
if (valid) {
options[index].removeAttribute(DISABLED);
} else {
options[index].setAttribute(DISABLED, DISABLED);
var currentValue = "" + item.get(resource.dataValueField);
if (valueArray.indexOf(currentValue) >= 0) {
if (isMs) {
valueArray.splice(valueArray.indexOf(currentValue), 1);
} else {
currentEditor.val(null);
currentEditor.trigger(CHANGE);
}
}
}
});
if (isMs && valueArray.length < editorValue.length) {
currentEditor.val(valueArray);
currentEditor.trigger(CHANGE);
}
}
function dropDownResourceEditor(resource, model, parent) {
var attr = createValidationAttributes(model, resource.field);
return function(container) {
var currentEditor;
if (parent) {
setTimeout(function() {
filterResourceEditorData(currentEditor, model[parent], resource.dataParentValueField, resource.dataValueField);
bindParentValueChangeHandler(container, currentEditor, resource, parent);
});
}
currentEditor = $(kendo.format('<select aria-labelledby="' + resource.field + '_label" data-{0}bind="value:{1}" title="' + model.title + '">', kendo.ns, resource.field))
.appendTo(container)
.attr(attr)
.kendoDropDownList({
dataTextField: resource.dataTextField,
dataValueField: resource.dataValueField,
dataSource: resource.dataSource.data(),
valuePrimitive: resource.valuePrimitive,
optionLabel: "None",
template: (data) => `<span ${data.disabled ? "data-disabled" : ""}><span class="k-scheduler-mark" ${kendo.attr("style-background-color")}="${data[resource.dataColorField] || "none"}"></span>${data[resource.dataTextField]}</span>`,
select: function(e) {
if (e.dataItem && e.dataItem.disabled) {
e.preventDefault();
}
},
dataBound: function(e) {
let options = e.sender.list.find('li');
for (let i = 0; i < options.length; i++) {
var element = options.eq(i);
if (element.find("[data-disabled]").length > 0) {
element.addClass("k-disabled");
}
}
}
}).data("kendoDropDownList");
};
}
function dropDownResourceEditorMobile(resource, model, parent) {
var attr = createValidationAttributes(model, resource.field);
return function(container) {
var options = "";
var view = resource.dataSource.view();
for (var idx = 0, length = view.length; idx < length; idx++) {
options += kendo.format('<option value="{0}">{1}</option>',
kendo.getter(resource.dataValueField)(view[idx]),
kendo.getter(resource.dataTextField)(view[idx])
);
}
var currentEditor = $(kendo.format('<select aria-labelledby="' + resource.field + '_label" data-{0}bind="value:{1}">{2}</select>',
kendo.ns,
resource.field,
options
))
.appendTo(container)
.attr(attr);
if (parent) {
setTimeout(function() {
var parentElement = container.closest(".k-stretched-view").find("[data-" + kendo.ns + "bind='value:" + parent + "']");
var parentSelectedValue = model[parent];
filterMobileResourceEditorData(resource, currentEditor, parentSelectedValue);
parentElement.on(CHANGE, function(ev) {
var parentValue = ev.target.value;
filterMobileResourceEditorData(resource, currentEditor, parentValue);
});
});
}
};
}
function multiSelectResourceEditor(resource, model, parent) {
var attr = createValidationAttributes(model, resource.field);
return function(container) {
var currentEditor;
if (parent) {
setTimeout(function() {
filterResourceEditorData(currentEditor, model[parent], resource.dataParentValueField, resource.dataValueField);
bindParentValueChangeHandler(container, currentEditor, resource, parent);
});
}
currentEditor = $(kendo.format('<select aria-labelledby="' + resource.field + '_label" data-{0}bind="value:{1}">', kendo.ns, resource.field))
.appendTo(container)
.attr(attr)
.kendoMultiSelect({
dataTextField: resource.dataTextField,
dataValueField: resource.dataValueField,
dataSource: resource.dataSource.data(),
valuePrimitive: resource.valuePrimitive,
itemTemplate: (data