@syncfusion/ej2-schedule
Version:
Flexible scheduling library with more built-in features and enhanced customization options similar to outlook and google calendar, allowing the users to plan and manage their appointments with efficient data-binding support.
952 lines (951 loc) • 80.8 kB
JavaScript
/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable max-len */
import { isNullOrUndefined, closest, extend, EventHandler, setStyleAttribute } from '@syncfusion/ej2-base';
import { createElement, prepend, append, addClass, removeClass } from '@syncfusion/ej2-base';
import { DataManager, Query, Predicate } from '@syncfusion/ej2-data';
import { generate, getDateFromRecurrenceDateString } from '../../recurrence-editor/date-generator';
import * as util from '../base/util';
import * as cls from '../base/css-constant';
import * as event from '../base/constant';
/**
* EventBase for appointment rendering
*/
var EventBase = /** @class */ (function () {
/**
* Constructor for EventBase
*
* @param {Schedule} parent Accepts the schedule instance
*/
function EventBase(parent) {
this.slots = [];
this.processedData = [];
this.isDoubleTapped = false;
this.parent = parent;
}
EventBase.prototype.processData = function (events, timeZonePropChanged, oldTimezone) {
var _this = this;
var start = this.parent.activeView.startDate();
var end = this.parent.activeView.endDate();
var fields = this.parent.eventFields;
var processed = [];
var temp = 1;
var generateID = false;
var resourceCollection = this.parent.resourceBase ? this.parent.resourceBase.resourceCollection : [];
if (events.length > 0 && isNullOrUndefined(events[0][fields.id])) {
generateID = true;
}
var _loop_1 = function (event_1) {
if (generateID) {
event_1[fields.id] = temp++;
}
event_1 = this_1.updateEventDateTime(event_1);
if (timeZonePropChanged) {
this_1.processTimezoneChange(event_1, oldTimezone);
}
else if (!this_1.parent.isPrinting && !this_1.parent.uiStateValues.isPreventTimezone) {
event_1 = this_1.processTimezone(event_1);
}
for (var level = 0; level < resourceCollection.length; level++) {
if (event_1[resourceCollection[parseInt(level.toString(), 10)].field] === null || event_1[resourceCollection[parseInt(level.toString(), 10)].field] === 0) {
event_1[resourceCollection[parseInt(level.toString(), 10)].field] = undefined;
}
}
if (!isNullOrUndefined(event_1[fields.recurrenceRule]) && event_1[fields.recurrenceRule] === '') {
event_1[fields.recurrenceRule] = null;
}
if (!isNullOrUndefined(event_1[fields.recurrenceRule]) && isNullOrUndefined(event_1[fields.recurrenceID]) &&
!(this_1.parent.crudModule && this_1.parent.crudModule.crudObj.isCrudAction)) {
processed = processed.concat(this_1.generateOccurrence(event_1, null, true));
}
else {
if (this_1.parent.crudModule && this_1.parent.crudModule.crudObj.isCrudAction) {
if (!isNullOrUndefined(event_1[fields.recurrenceRule]) && isNullOrUndefined(event_1[fields.recurrenceID])) {
var recurrenceEvent = this_1.generateOccurrence(event_1, null, true);
var _loop_2 = function (occurrence) {
var app = this_1.parent.eventsProcessed.filter(function (data) {
return data[fields.startTime].getTime() - occurrence[fields.startTime].getTime() === 0 &&
data[fields.id] === occurrence[fields.id];
});
occurrence.Guid = (app.length > 0) ? app[0].Guid : this_1.generateGuid();
processed.push(occurrence);
};
for (var _i = 0, recurrenceEvent_1 = recurrenceEvent; _i < recurrenceEvent_1.length; _i++) {
var occurrence = recurrenceEvent_1[_i];
_loop_2(occurrence);
}
}
else {
var app = this_1.parent.eventsProcessed.filter(function (data) {
return data[_this.parent.eventFields.id] === event_1[_this.parent.eventFields.id];
});
event_1.Guid = (app.length > 0) ? app[0].Guid : this_1.generateGuid();
processed.push(event_1);
}
}
else {
event_1.Guid = this_1.generateGuid();
processed.push(event_1);
}
}
};
var this_1 = this;
for (var _i = 0, events_1 = events; _i < events_1.length; _i++) {
var event_1 = events_1[_i];
_loop_1(event_1);
}
this.parent.eventsProcessed = [];
var eventData = processed.filter(function (data) {
return !data[_this.parent.eventFields.isBlock];
});
this.parent.eventsProcessed = this.filterEvents(start, end, eventData);
if (!this.parent.activeViewOptions.allowOverlap && this.parent.eventsProcessed.length > 0) {
this.processedData = this.parent.eventsProcessed;
var nonOverlapList = [];
var fields_1 = this.parent.eventFields;
for (var _a = 0, _b = this.parent.eventsProcessed; _a < _b.length; _a++) {
var data = _b[_a];
var overlappingData = this.findOverlappingData(data, nonOverlapList);
if (!overlappingData) {
nonOverlapList.push(data);
}
else if (!this.parent.eventSettings.sortComparer) {
var dataDuration = new Date(data[fields_1.endTime]).getTime() - new Date(data[fields_1.startTime]).getTime();
var duplicateDuration = new Date(overlappingData[fields_1.endTime]).getTime() - new Date(overlappingData[fields_1.startTime]).getTime();
if ((dataDuration > duplicateDuration && data[fields_1.startTime] === overlappingData[fields_1.startTime]) || (data[fields_1.isAllDay] === true)) {
var index = nonOverlapList.indexOf(overlappingData);
if (index !== -1) {
nonOverlapList.splice(index, 1);
}
nonOverlapList.push(data);
}
}
}
this.parent.eventsProcessed = nonOverlapList;
}
var blockData = processed.filter(function (data) {
return data[_this.parent.eventFields.isBlock];
});
for (var _c = 0, blockData_1 = blockData; _c < blockData_1.length; _c++) {
var eventObj = blockData_1[_c];
if (eventObj[fields.isAllDay]) {
var isDifferentDate = util.resetTime(new Date(eventObj[fields.startTime].getTime())) <
util.resetTime(new Date(eventObj[fields.endTime].getTime()));
if (!isDifferentDate) {
eventObj[fields.startTime] = util.resetTime(eventObj[fields.startTime]);
eventObj[fields.endTime] = util.addDays(util.resetTime(eventObj[fields.endTime]), 1);
}
}
}
this.parent.blockProcessed = blockData;
return eventData;
};
EventBase.prototype.findOverlappingData = function (eventData, eventList) {
var isResource = this.parent.activeViewOptions.group.resources.length > 0;
var resourceCollection = isResource ? this.parent.resourceBase.resourceCollection : [];
var lastLevelResource = isResource ? resourceCollection[resourceCollection.length - 1].field : null;
var fields = this.parent.eventFields;
var newStartTime = new Date(eventData[fields.startTime]);
var newEndTime = new Date(eventData[fields.endTime]);
for (var _i = 0, eventList_1 = eventList; _i < eventList_1.length; _i++) {
var existingEvent = eventList_1[_i];
if (newStartTime < existingEvent[fields.endTime] &&
newEndTime > existingEvent[fields.startTime] &&
existingEvent[fields.id] !== eventData[fields.id] &&
(!isResource || isNullOrUndefined(lastLevelResource) ||
this.compareResourceValues(existingEvent["" + lastLevelResource], eventData["" + lastLevelResource]))) {
return existingEvent;
}
}
return undefined;
};
EventBase.prototype.isOverlapRange = function (eventData, currentAction) {
var _this = this;
if (currentAction === void 0) { currentAction = null; }
var isResource = this.parent.activeViewOptions.group.resources.length > 0;
var resourceCollection = isResource ? this.parent.resourceBase.resourceCollection : [];
var lastLevelResource = isResource ? resourceCollection[resourceCollection.length - 1].field : null;
var eventCollection = Array.isArray(eventData) ? eventData : [eventData];
var fields = this.parent.eventFields;
var processOverlappingEvents = function (data) {
return _this.processedData.filter(function (x) {
return data[fields.startTime] < x[fields.endTime] &&
data[fields.endTime] > x[fields.startTime] &&
x[fields.id] !== data[fields.id] &&
(!isResource || isNullOrUndefined(lastLevelResource) || _this.compareResourceValues(x["" + lastLevelResource], data["" + lastLevelResource]));
});
};
var overlappedEvents = [];
var isOverlapAlert = false;
for (var _i = 0, eventCollection_1 = eventCollection; _i < eventCollection_1.length; _i++) {
var event_2 = eventCollection_1[_i];
var dataCol = !isNullOrUndefined(event_2[fields.recurrenceRule]) &&
(isNullOrUndefined(event_2[fields.recurrenceID]) || event_2[fields.recurrenceID] === event_2[fields.id]) &&
(isNullOrUndefined(event_2[fields.recurrenceID]) || currentAction === 'EditSeries')
? this.generateOccurrence(event_2)
: [event_2];
for (var _a = 0, dataCol_1 = dataCol; _a < dataCol_1.length; _a++) {
var data = dataCol_1[_a];
var overlappingEvents = processOverlappingEvents(data);
if (overlappingEvents.length > 0) {
overlappedEvents.push.apply(overlappedEvents, overlappingEvents);
}
if (this.findOverlappingData(data, this.parent.eventsProcessed)) {
isOverlapAlert = true;
}
}
}
this.parent.overlapAppointments = overlappedEvents;
return isOverlapAlert;
};
EventBase.prototype.compareResourceValues = function (a, b) {
var getValue = function (value) { return Array.isArray(value) ? value[0] : value; };
return getValue(a) === getValue(b);
};
EventBase.prototype.checkOverlap = function (eventData) {
if (!this.parent.activeViewOptions.allowOverlap) {
if (this.isOverlapRange(eventData)) {
this.parent.quickPopup.openValidationError('overlapAlert', eventData);
return true;
}
}
return false;
};
EventBase.prototype.updateEventDateTime = function (eventData) {
if (typeof eventData[this.parent.eventFields.startTime] === 'string') {
eventData[this.parent.eventFields.startTime] = util.getDateFromString(eventData[this.parent.eventFields.startTime]);
}
if (typeof eventData[this.parent.eventFields.endTime] === 'string') {
eventData[this.parent.eventFields.endTime] = util.getDateFromString(eventData[this.parent.eventFields.endTime]);
}
return eventData;
};
EventBase.prototype.getProcessedEvents = function (eventCollection) {
if (eventCollection === void 0) { eventCollection = this.parent.eventsData; }
var processed = [];
for (var _i = 0, eventCollection_2 = eventCollection; _i < eventCollection_2.length; _i++) {
var event_3 = eventCollection_2[_i];
if (!isNullOrUndefined(event_3[this.parent.eventFields.recurrenceRule]) &&
isNullOrUndefined(event_3[this.parent.eventFields.recurrenceID])) {
processed = processed.concat(this.generateOccurrence(event_3));
}
else {
processed.push(event_3);
}
}
return processed;
};
EventBase.prototype.timezonePropertyChange = function (oldTimezone) {
var data = this.parent.eventsData.concat(this.parent.blockData);
var processed = this.processData(data, true, oldTimezone);
this.parent.notify(event.dataReady, { processedData: processed });
};
EventBase.prototype.timezoneConvert = function (eventData) {
var fields = this.parent.eventFields;
eventData[fields.startTimezone] = eventData[fields.startTimezone] || eventData[fields.endTimezone];
eventData[fields.endTimezone] = eventData[fields.endTimezone] || eventData[fields.startTimezone];
if (this.parent.timezone) {
var startTz = eventData[fields.startTimezone];
var endTz = eventData[fields.endTimezone];
eventData[fields.startTime] = this.parent.tzModule.convert(eventData[fields.startTime], this.parent.timezone, startTz);
eventData[fields.endTime] = this.parent.tzModule.convert(eventData[fields.endTime], this.parent.timezone, endTz);
}
};
EventBase.prototype.processTimezoneChange = function (event, oldTimezone) {
var fields = this.parent.eventFields;
if (event[fields.isAllDay]) {
return;
}
if (oldTimezone && this.parent.timezone) {
event[fields.startTime] = this.parent.tzModule.convert(event[fields.startTime], oldTimezone, this.parent.timezone);
event[fields.endTime] = this.parent.tzModule.convert(event[fields.endTime], oldTimezone, this.parent.timezone);
}
else if (!oldTimezone && this.parent.timezone) {
event[fields.startTime] = this.parent.tzModule.add(event[fields.startTime], this.parent.timezone);
event[fields.endTime] = this.parent.tzModule.add(event[fields.endTime], this.parent.timezone);
}
else if (oldTimezone && !this.parent.timezone) {
event[fields.startTime] = this.parent.tzModule.remove(event[fields.startTime], oldTimezone);
event[fields.endTime] = this.parent.tzModule.remove(event[fields.endTime], oldTimezone);
}
};
EventBase.prototype.processTimezone = function (event, isReverse) {
if (isReverse === void 0) { isReverse = false; }
var fields = this.parent.eventFields;
if (event[fields.isAllDay]) {
return event;
}
if (event[fields.startTimezone] || event[fields.endTimezone]) {
var startTimezone = event[fields.startTimezone] || event[fields.endTimezone];
var endTimezone = event[fields.endTimezone] || event[fields.startTimezone];
if (isReverse) {
if (this.parent.timezone) {
event[fields.startTime] = this.parent.tzModule.convert(event[fields.startTime], startTimezone, this.parent.timezone);
event[fields.endTime] = this.parent.tzModule.convert(event[fields.endTime], endTimezone, this.parent.timezone);
event[fields.startTime] = this.parent.tzModule.remove(event[fields.startTime], this.parent.timezone);
event[fields.endTime] = this.parent.tzModule.remove(event[fields.endTime], this.parent.timezone);
}
else {
event[fields.startTime] = this.parent.tzModule.remove(event[fields.startTime], startTimezone);
event[fields.endTime] = this.parent.tzModule.remove(event[fields.endTime], endTimezone);
}
}
else {
event[fields.startTime] = this.parent.tzModule.add(event[fields.startTime], startTimezone);
event[fields.endTime] = this.parent.tzModule.add(event[fields.endTime], endTimezone);
if (this.parent.timezone) {
event[fields.startTime] = this.parent.tzModule.convert(event[fields.startTime], startTimezone, this.parent.timezone);
event[fields.endTime] = this.parent.tzModule.convert(event[fields.endTime], endTimezone, this.parent.timezone);
}
}
}
else if (this.parent.timezone) {
if (isReverse) {
event[fields.startTime] = this.parent.tzModule.remove(event[fields.startTime], this.parent.timezone);
event[fields.endTime] = this.parent.tzModule.remove(event[fields.endTime], this.parent.timezone);
}
else {
event[fields.startTime] = this.parent.tzModule.add(event[fields.startTime], this.parent.timezone);
event[fields.endTime] = this.parent.tzModule.add(event[fields.endTime], this.parent.timezone);
}
}
return event;
};
EventBase.prototype.filterBlockEvents = function (eventObj) {
var fields = this.parent.eventFields;
var eStart = eventObj[fields.startTime];
var eEnd = eventObj[fields.endTime];
var resourceData;
if (this.parent.activeViewOptions.group.resources.length > 0) {
var data = this.getGroupIndexFromEvent(eventObj);
resourceData = this.parent.resourceBase.lastResourceLevel[parseInt(data.toString(), 10)];
}
var blockEvents = extend([], this.parent.blockProcessed, null, true);
for (var _i = 0, blockEvents_1 = blockEvents; _i < blockEvents_1.length; _i++) {
var eventObj_1 = blockEvents_1[_i];
if (eventObj_1[fields.isAllDay]) {
var isDifferentTime = eventObj_1[fields.endTime].getTime() >
util.resetTime(new Date(eventObj_1[fields.endTime].getTime())).getTime();
if (isDifferentTime) {
eventObj_1[fields.startTime] = util.resetTime(eventObj_1[fields.startTime]);
eventObj_1[fields.endTime] = util.addDays(util.resetTime(eventObj_1[fields.endTime]), 1);
}
}
}
return this.filterEvents(eStart, eEnd, blockEvents, resourceData);
};
EventBase.prototype.filterEvents = function (startDate, endDate, appointments, resourceTdData) {
if (appointments === void 0) { appointments = this.parent.eventsProcessed; }
var predicate = this.parent.dataModule.getStartEndQuery(startDate, endDate);
var filter = new DataManager({ json: appointments }).executeLocal(new Query().where(predicate));
if (resourceTdData) {
filter = this.filterEventsByResource(resourceTdData, filter);
}
return this.sortByTime(filter);
};
EventBase.prototype.filterEventsByRange = function (eventCollection, startDate, endDate) {
var _this = this;
var filteredEvents = [];
if (startDate && endDate) {
filteredEvents = this.filterEvents(startDate, endDate, eventCollection);
}
else if (startDate && !endDate) {
filteredEvents = eventCollection.filter(function (e) { return e[_this.parent.eventFields.startTime] >= startDate; });
}
else if (!startDate && endDate) {
filteredEvents = eventCollection.filter(function (e) { return e[_this.parent.eventFields.endTime] <= endDate; });
}
else {
filteredEvents = eventCollection;
}
return this.sortByTime(filteredEvents);
};
EventBase.prototype.filterEventsByResource = function (resourceTdData, appointments) {
if (appointments === void 0) { appointments = this.parent.eventsProcessed; }
var predicate = {};
var resourceCollection = this.parent.resourceBase.resourceCollection;
for (var level = 0; level < resourceCollection.length; level++) {
predicate[resourceCollection[parseInt(level.toString(), 10)].field] = resourceTdData.groupOrder[parseInt(level.toString(), 10)];
}
var keys = Object.keys(predicate);
var filteredCollection = appointments.filter(function (eventObj) { return keys.every(function (key) {
if (eventObj["" + key] instanceof Array) {
return eventObj["" + key].indexOf(predicate["" + key]) > -1;
}
else {
return eventObj["" + key] === predicate["" + key];
}
}); });
return filteredCollection;
};
EventBase.prototype.sortByTime = function (appointmentsCollection) {
if (this.parent.eventSettings.sortComparer && (typeof (this.parent.eventSettings.sortComparer) === 'function' || typeof (this.parent.eventSettings.sortComparer) === 'string')) {
appointmentsCollection = this.customSorting(appointmentsCollection);
}
else {
var fieldMappings_1 = this.parent.eventFields;
appointmentsCollection.sort(function (a, b) {
var d1 = a[fieldMappings_1.startTime];
var d2 = b[fieldMappings_1.startTime];
return d1.getTime() - d2.getTime();
});
}
return appointmentsCollection;
};
EventBase.prototype.sortByDateTime = function (appointments) {
if (this.parent.eventSettings.sortComparer && (typeof (this.parent.eventSettings.sortComparer) === 'function' || typeof (this.parent.eventSettings.sortComparer) === 'string')) {
appointments = this.customSorting(appointments);
}
else {
var fieldMapping_1 = this.parent.eventFields;
appointments.sort(function (object1, object2) {
var d3 = object1[fieldMapping_1.startTime];
var d4 = object2[fieldMapping_1.startTime];
var d5 = object1[fieldMapping_1.endTime];
var d6 = object2[fieldMapping_1.endTime];
var d1 = d5.getTime() - d3.getTime();
var d2 = d6.getTime() - d4.getTime();
return (d3.getTime() - d4.getTime() || d2 - d1);
});
}
return appointments;
};
EventBase.prototype.customSorting = function (appointments) {
if (typeof (this.parent.eventSettings.sortComparer) === 'function') {
return this.parent.eventSettings.sortComparer.call(this.parent, appointments);
}
else if (typeof (this.parent.eventSettings.sortComparer) === 'string') {
var splits = this.parent.eventSettings.sortComparer.split('.');
var sortFn = void 0;
if (!isNullOrUndefined(window)) {
sortFn = window[splits[splits.length - 1]];
}
if (sortFn) {
return sortFn(appointments);
}
}
return appointments;
};
EventBase.prototype.getSmallestMissingNumber = function (array) {
var large = Math.max.apply(Math, array);
for (var i = 0; i < large; i++) {
if (array.indexOf(i) === -1) {
return i;
}
}
return large + 1;
};
EventBase.prototype.splitEventByDay = function (event) {
var eventFields = this.parent.eventFields;
var data = [];
var eventStartTime = event[eventFields.startTime];
var eventEndTime = event[eventFields.endTime];
var isDifferentDate = util.resetTime(new Date(eventStartTime.getTime())) <
util.resetTime(new Date(eventEndTime.getTime()));
if (isDifferentDate) {
var start = new Date(eventStartTime.getTime());
var end = util.addDays(util.resetTime(new Date(eventStartTime.getTime())), 1);
var endDate = (eventEndTime.getHours() === 0 && eventEndTime.getMinutes() === 0) ?
eventEndTime : util.addDays(eventEndTime, 1);
var index = 1;
var eventLength = util.getDaysCount(eventStartTime.getTime(), endDate.getTime());
while (end <= eventEndTime && start.getTime() !== end.getTime()) {
var app = extend({}, event);
app[eventFields.startTime] = start;
app[eventFields.endTime] = end;
app.data = { index: index, count: eventLength };
app.Guid = this.generateGuid();
app.isSpanned = true;
data.push(app);
start = end;
if ((util.resetTime(new Date(start.getTime())).getTime() === util.resetTime(new Date(eventEndTime.getTime())).getTime())
&& !(end.getTime() === eventEndTime.getTime())) {
end = new Date(start.getTime());
end = new Date(end.setHours(eventEndTime.getHours(), eventEndTime.getMinutes(), eventEndTime.getSeconds()));
}
else {
end = util.addDays(util.resetTime(new Date(start.getTime())), 1);
}
index++;
}
}
else {
data.push(event);
}
return data;
};
EventBase.prototype.splitEvent = function (event, dateRender) {
var fields = this.parent.eventFields;
var start = util.resetTime(event[fields.startTime]).getTime();
var end = util.resetTime(event[fields.endTime]).getTime();
if (util.getDateInMs(event[fields.endTime]) <= 0) {
var temp = util.addDays(util.resetTime(event[fields.endTime]), -1).getTime();
end = start > temp ? start : temp;
}
var orgStart = start;
var orgEnd = end;
var ranges = [];
if (start !== end) {
if (start < dateRender[0].getTime()) {
start = dateRender[0].getTime();
}
if (end > dateRender[dateRender.length - 1].getTime()) {
end = dateRender[dateRender.length - 1].getTime();
}
var cStart = start;
for (var level = 0; level < this.slots.length; level++) {
var slot = this.slots[parseInt(level.toString(), 10)];
if (this.parent.currentView === 'WorkWeek' || this.parent.currentView === 'TimelineWorkWeek'
|| this.parent.activeViewOptions.group.byDate || this.parent.activeViewOptions.showWeekend) {
var slotDates = [];
for (var _i = 0, slot_1 = slot; _i < slot_1.length; _i++) {
var s = slot_1[_i];
slotDates.push(new Date(s));
}
var renderedDates = this.getRenderedDates(slotDates);
if (!isNullOrUndefined(renderedDates) && renderedDates.length > 0) {
slot = [];
for (var _a = 0, renderedDates_1 = renderedDates; _a < renderedDates_1.length; _a++) {
var date = renderedDates_1[_a];
slot.push(date.getTime());
}
}
}
if (typeof (slot) === 'number') {
var temp = slot;
slot = [];
slot.push(temp);
}
var firstSlot = slot[0];
cStart = (cStart <= firstSlot && end >= firstSlot) ? firstSlot : cStart;
if (cStart > end || firstSlot > end) {
break;
}
if (!this.parent.activeViewOptions.group.byDate && this.parent.activeViewOptions.showWeekend &&
this.parent.currentView !== 'WorkWeek' && this.parent.currentView !== 'TimelineWorkWeek') {
var startIndex = slot.indexOf(cStart);
if (startIndex !== -1) {
var endIndex = slot.indexOf(end);
var hasBreak = endIndex !== -1;
endIndex = hasBreak ? endIndex : slot.length - 1;
var count = ((endIndex - startIndex) + 1);
var isLeft = (slot[parseInt(startIndex.toString(), 10)] !== orgStart);
var isRight = (slot[parseInt(endIndex.toString(), 10)] !== orgEnd);
ranges.push(this.cloneEventObject(event, slot[parseInt(startIndex.toString(), 10)], slot[parseInt(endIndex.toString(), 10)], count, isLeft, isRight));
if (hasBreak) {
break;
}
}
}
else {
if (this.dateInRange(cStart, slot[0], slot[slot.length - 1])) {
var availSlot = [];
for (var i = 0; i < slot.length; i++) {
if (this.dateInRange(slot[parseInt(i.toString(), 10)], orgStart, orgEnd)) {
availSlot.push(slot[parseInt(i.toString(), 10)]);
}
}
if (availSlot.length > 0) {
if (!this.parent.activeViewOptions.group.byDate) {
var isLeft = (availSlot[0] !== orgStart);
var isRight = (availSlot[availSlot.length - 1] !== orgEnd);
ranges.push(this.cloneEventObject(event, availSlot[0], availSlot[availSlot.length - 1], availSlot.length, isLeft, isRight));
}
else {
for (var _b = 0, availSlot_1 = availSlot; _b < availSlot_1.length; _b++) {
var slot_2 = availSlot_1[_b];
ranges.push(this.cloneEventObject(event, slot_2, slot_2, 1, (slot_2 !== orgStart), (slot_2 !== orgEnd)));
}
}
}
}
}
}
}
else {
ranges.push(this.cloneEventObject(event, start, end, 1, false, false));
}
return ranges;
};
EventBase.prototype.cloneEventObject = function (event, start, end, count, isLeft, isRight) {
var fields = this.parent.eventFields;
var e = extend({}, event, null, true);
var data = { count: count, isLeft: isLeft, isRight: isRight };
data[fields.startTime] = event[fields.startTime];
data[fields.endTime] = event[fields.endTime];
e.data = data;
e[fields.startTime] = new Date(start);
e[fields.endTime] = new Date(end);
return e;
};
EventBase.prototype.dateInRange = function (date, start, end) {
return start <= date && date <= end;
};
EventBase.prototype.getSelectedEventElements = function (target) {
this.removeSelectedAppointmentClass();
if (this.parent.selectedElements.length <= 0) {
this.parent.selectedElements.push(target);
}
else {
var isAlreadySelected = this.parent.selectedElements.filter(function (element) {
return element.getAttribute('data-guid') === target.getAttribute('data-guid');
});
if (isAlreadySelected.length <= 0) {
var elementSelector = 'div[data-guid="' + target.getAttribute('data-guid') + '"]';
var focusElements = [].slice.call(this.parent.element.querySelectorAll(elementSelector));
for (var _i = 0, focusElements_1 = focusElements; _i < focusElements_1.length; _i++) {
var element = focusElements_1[_i];
this.parent.selectedElements.push(element);
}
}
else {
var selectedElements = this.parent.selectedElements.filter(function (element) {
return element.getAttribute('data-guid') !== target.getAttribute('data-guid');
});
this.parent.selectedElements = selectedElements;
}
}
if (target && this.parent.selectedElements.length > 0) {
this.addSelectedAppointments(this.parent.selectedElements, false);
}
return this.parent.selectedElements;
};
EventBase.prototype.getSelectedEvents = function () {
var _this = this;
var eventSelect = [];
var elementSelect = [];
var selectAppointments = [].slice.call(this.parent.element.querySelectorAll('.' + cls.APPOINTMENT_BORDER));
selectAppointments.filter(function (element) {
var isAlreadyAdded = eventSelect.filter(function (event) {
return event.Guid === element.getAttribute('data-guid');
});
if (isAlreadyAdded.length === 0) {
eventSelect.push(_this.getEventByGuid(element.getAttribute('data-guid')));
}
elementSelect.push(element);
});
return {
event: eventSelect.length > 1 ? eventSelect : eventSelect[0],
element: elementSelect.length > 1 ? elementSelect : elementSelect[0]
};
};
EventBase.prototype.removeSelectedAppointmentClass = function () {
var selectedAppointments = this.getSelectedAppointments();
removeClass(selectedAppointments, cls.APPOINTMENT_BORDER);
if (this.parent.currentView === 'Agenda' || this.parent.currentView === 'MonthAgenda') {
removeClass(selectedAppointments, cls.AGENDA_SELECTED_CELL);
}
};
EventBase.prototype.addSelectedAppointments = function (cells, preventFocus) {
if (this.parent.currentView !== 'MonthAgenda') {
this.parent.removeSelectedClass();
}
addClass(cells, cls.APPOINTMENT_BORDER);
if (cells.length > 0 && !preventFocus) {
cells[cells.length - 1].focus();
}
};
EventBase.prototype.getSelectedAppointments = function () {
return [].slice.call(this.parent.element.querySelectorAll('.' + cls.APPOINTMENT_BORDER + ',.' + cls.APPOINTMENT_CLASS + ':focus'));
};
EventBase.prototype.focusElement = function (isFocused) {
if (this.parent.eventWindow.dialogObject && this.parent.eventWindow.dialogObject.visible) {
return;
}
var activeEle = document.activeElement;
var selectedCell = this.parent.getSelectedCells();
if (selectedCell.length > 0 && ((activeEle && (this.parent.element.contains(activeEle) ||
selectedCell.indexOf(activeEle) !== -1)) || isFocused)) {
if (this.parent.keyboardInteractionModule) {
var target = ((!isNullOrUndefined(this.parent.activeCellsData) &&
this.parent.activeCellsData.element) || selectedCell[selectedCell.length - 1]);
this.parent.keyboardInteractionModule.selectCells(target instanceof Array, target);
}
return;
}
var selectedAppointments = this.getSelectedAppointments();
if (selectedAppointments.length > 0) {
if (this.parent.activeEventData && this.parent.activeEventData.element && selectedAppointments.indexOf(this.parent.activeEventData.element) > -1) {
this.parent.activeEventData.element.focus();
return;
}
selectedAppointments[selectedAppointments.length - 1].focus();
return;
}
};
EventBase.prototype.selectWorkCellByTime = function (eventsData) {
var target;
if (this.parent.currentView === 'Agenda' || this.parent.currentView === 'MonthAgenda') {
return target;
}
if (eventsData.length > 0) {
var selectedObject = eventsData[eventsData.length - 1];
var eventStartTime = selectedObject[this.parent.eventFields.startTime];
var nearestTime = void 0;
var isAllDay = this.isAllDayAppointment(selectedObject);
if (this.parent.currentView === 'Month' || isAllDay || !this.parent.activeViewOptions.timeScale.enable) {
nearestTime = new Date(+eventStartTime).setHours(0, 0, 0, 0);
}
else {
nearestTime = this.findNearestSlot(eventStartTime);
}
var targetArea = void 0;
if (isAllDay && ['Day', 'Week', 'WorkWeek'].indexOf(this.parent.currentView) !== -1) {
targetArea = this.parent.getAllDayRow();
}
else {
targetArea = this.parent.getContentTable();
}
var queryString = '[data-date="' + new Date(nearestTime).getTime() + '"]';
if (!isNullOrUndefined(this.parent.activeViewOptions.group.resources) &&
this.parent.activeViewOptions.group.resources.length > 0) {
queryString += '[data-group-index="' + this.getGroupIndexFromEvent(selectedObject) + '"]';
}
target = targetArea.querySelector(queryString);
if (target) {
this.parent.activeCellsData = this.parent.getCellDetails(target);
if (this.parent.keyboardInteractionModule) {
this.parent.keyboardInteractionModule.selectCells(false, target);
}
return target;
}
}
return target;
};
EventBase.prototype.findNearestSlot = function (appointmentTime) {
var msMajorInterval = this.parent.activeViewOptions.timeScale.interval * util.MS_PER_MINUTE;
var msInterval = msMajorInterval / this.parent.activeViewOptions.timeScale.slotCount;
var numberOfSlots = Math.round(util.MS_PER_DAY / msInterval);
var startTime = new Date(appointmentTime);
startTime.setHours(0, 0, 0, 0);
var slots = Array.from({ length: numberOfSlots }, function (_, i) {
var slotTime = new Date(startTime.getTime() + i * msInterval);
return slotTime;
});
var nearestSlot = slots.reduce(function (nearest, slot) {
var difference = Math.abs(appointmentTime.getTime() - slot.getTime());
if (!nearest || difference < Math.abs(appointmentTime.getTime() - nearest.getTime())) {
return slot;
}
return nearest;
}, null);
return Math.trunc(nearestSlot.getTime() / 1000) * 1000;
};
EventBase.prototype.getGroupIndexFromEvent = function (eventData) {
var levelIndex;
var resource;
var levelName;
var idField;
for (var i = this.parent.resourceBase.resourceCollection.length - 1; i >= 0; i--) {
var resourceData = eventData[this.parent.resourceBase.resourceCollection[parseInt(i.toString(), 10)].field];
if (!isNullOrUndefined(resourceData)) {
resource = this.parent.resourceBase.resourceCollection[parseInt(i.toString(), 10)];
levelIndex = i;
levelName = resource.name;
idField = resource.field;
break;
}
}
if (isNullOrUndefined(levelName) && isNullOrUndefined(levelIndex)) {
levelName = this.parent.resourceCollection.slice(-1)[0].name;
levelIndex = this.parent.resourceCollection.length - 1;
idField = this.parent.resourceCollection.slice(-1)[0].field;
resource = this.parent.resourceCollection.filter(function (e, index) {
if (e.name === levelName) {
levelIndex = index;
return e;
}
return null;
})[0];
}
var id = ((eventData["" + idField] instanceof Array) ?
eventData["" + idField][0] : eventData["" + idField]);
if (levelIndex > 0) {
var parentField = this.parent.resourceCollection[levelIndex - 1].field;
return this.parent.resourceBase.getIndexFromResourceId(id, levelName, resource, eventData, parentField);
}
else {
return this.parent.resourceBase.getIndexFromResourceId(id, levelName, resource);
}
};
EventBase.prototype.isAllDayAppointment = function (event) {
var fieldMapping = this.parent.eventFields;
var isAllDay = event[fieldMapping.isAllDay];
var isFullDay = ((util.getUniversalTime(event[fieldMapping.endTime]) - util.getUniversalTime(event[fieldMapping.startTime]))
/ util.MS_PER_DAY) >= 1;
return (isAllDay || (this.parent.eventSettings.spannedEventPlacement !== 'TimeSlot' && isFullDay)) ? true : false;
};
EventBase.prototype.addEventListener = function () {
this.parent.on(event.documentClick, this.appointmentBorderRemove, this);
};
EventBase.prototype.removeEventListener = function () {
this.parent.off(event.documentClick, this.appointmentBorderRemove);
};
EventBase.prototype.appointmentBorderRemove = function (event) {
var element = event.event.target;
if (closest(element, '.' + cls.APPOINTMENT_CLASS)) {
if (this.parent.currentView !== 'MonthAgenda') {
this.parent.removeSelectedClass();
}
}
else if (!closest(element, '.' + cls.POPUP_OPEN)) {
if (this.parent.uiStateValues.isTapHold && closest(element, '.' + cls.WORK_CELLS_CLASS + ',.' + cls.ALLDAY_CELLS_CLASS)) {
return;
}
this.parent.uiStateValues.isTapHold = false;
this.removeSelectedAppointmentClass();
this.parent.selectedElements = [];
}
};
EventBase.prototype.wireAppointmentEvents = function (element, event, isPreventCrud) {
if (isPreventCrud === void 0) { isPreventCrud = false; }
var isReadOnly = (!isNullOrUndefined(event)) ? event[this.parent.eventFields.isReadonly] : false;
EventHandler.add(element, 'click', this.eventClick, this);
if (!this.parent.isAdaptive && !this.parent.activeViewOptions.readonly && !isReadOnly) {
EventHandler.add(element, 'touchend', this.eventTouchClick, this);
EventHandler.add(element, 'dblclick', this.eventDoubleClick, this);
}
if (!this.parent.activeViewOptions.readonly && !isReadOnly && !isPreventCrud) {
if (this.parent.resizeModule) {
this.parent.resizeModule.wireResizeEvent(element);
}
if (this.parent.dragAndDropModule) {
this.parent.dragAndDropModule.wireDragEvent(element);
}
}
};
EventBase.prototype.eventTouchClick = function (e) {
var _this = this;
if (this.parent.uiStateValues.isTouchScroll || this.parent.uiStateValues.isTapHold || this.parent.uiStateValues.action) {
this.parent.uiStateValues.isTouchScroll = this.parent.uiStateValues.isTapHold = false;
return;
}
setTimeout(function () { return _this.isDoubleTapped = false; }, 250);
e.preventDefault();
if (this.isDoubleTapped) {
this.eventDoubleClick(e);
}
else if (!this.isDoubleTapped) {
this.isDoubleTapped = true;
this.eventClick(e);
}
};
EventBase.prototype.renderResizeHandler = function (element, spanEvent, isReadOnly) {
if (!this.parent.resizeModule || !this.parent.allowResizing || this.parent.activeViewOptions.readonly || isReadOnly) {
return;
}
for (var _i = 0, _a = Object.keys(spanEvent); _i < _a.length; _i++) {
var resizeEdge = _a[_i];
var resizeHandler = createElement('div', { className: cls.EVENT_RESIZE_CLASS });
switch (resizeEdge) {
case 'isLeft':
if (!spanEvent.isLeft) {
resizeHandler.appendChild(createElement('div', { className: 'e-left-right-resize' }));
addClass([resizeHandler], this.parent.enableRtl ? cls.RIGHT_RESIZE_HANDLER : cls.LEFT_RESIZE_HANDLER);
prepend([resizeHandler], element);
}
break;
case 'isRight':
if (!spanEvent.isRight) {
resizeHandler.appendChild(createElement('div', { className: 'e-left-right-resize' }));
addClass([resizeHandler], this.parent.enableRtl ? cls.LEFT_RESIZE_HANDLER : cls.RIGHT_RESIZE_HANDLER);
append([resizeHandler], element);
}
break;
case 'isTop':
if (!spanEvent.isTop) {
resizeHandler.appendChild(createElement('div', { className: 'e-top-bottom-resize' }));
addClass([resizeHandler], cls.TOP_RESIZE_HANDLER);
prepend([resizeHandler], element);
}
break;
case 'isBottom':
if (!spanEvent.isBottom) {
resizeHandler.appendChild(createElement('div', { className: 'e-top-bottom-resize' }));
addClass([resizeHandler], cls.BOTTOM_RESIZE_HANDLER);
append([resizeHandler], element);
}
break;
}
}
};
EventBase.prototype.eventClick = function (eventData) {
var _this = this;
var target = eventData.target;
if (target.classList.contains(cls.DRAG_CLONE_CLASS) || target.classList.contains(cls.RESIZE_CLONE_CLASS) ||
target.classList.contains(cls.INLINE_SUBJECT_CLASS)) {
return;
}
if ((eventData.ctrlKey || eventData.metaKey) && eventData.which === 1 && this.parent.keyboardInteractionModule) {
this.parent.quickPopup.quickPopup.hide();
this.parent.selectedElements = [].slice.call(this.parent.element.querySelectorAll('.' + cls.APPOINTMENT_BORDER));
var target_1 = closest(eventData.target, '.' + cls.APPOINTMENT_CLASS);
this.getSelectedEventElements(target_1);
this.activeEventData(eventData, false);
var selectArgs = {
data: this.parent.activeEventData.event,
element: this.parent.activeEventData.element,
event: eventData, requestType: 'eventSelect'
};
this.parent.trigger(event.select, selectArgs);
var args = extend(this.parent.activeEventData, { cancel: false, originalEvent: eventData });
this.parent.trigger(event.eventClick, args);
}
else {
this.removeSelectedAppointmentClass();
this.activeEventData(eventData, true);
var selectEventArgs = {
data: this.parent.activeEventData.event,
element: this.parent.activeEventData.element,
event: eventData, requestType: 'eventSelect'
};
this.parent.trigger(event.select, selectEventArgs);
var args = extend(this.parent.activeEventData, { cancel: false, originalEvent: eventData });
this.parent.trigger(event.eventClick, args, function (eventClickArgs) {
if (eventClickArgs.cancel) {
_this.removeSelectedAppointmentClass();
_this.parent.selectedElements = [];
if (_this.parent.quickPopup) {
_this.parent.quickPopup.quickPopupHide();
}
}
else {
if (_this.parent.currentView === 'Agenda' || _this.parent.currentView === 'MonthAgenda') {
addClass([_this.parent.activeEventData.element], cls.AGENDA_SELECTED_CELL);
}
if (_this.parent.allowInline) {
var inlineArgs = {
data: eventClickArgs.event,
element: eventClickArgs.element,
type: 'Event'
};
_this.parent.notify(event.inlineClick, inlineArgs);
}
else {
_this.parent.notify(event.eventClick, eventClickArgs);
}
}
});
}
};
EventBase.prototype.eventDoubleClick = function (eventData) {
var _this = this;
if (this.parent.quickPopup) {
this.parent.quickPopup.quickPopupHide(true);
}
if (eventData.type === 'touchend') {
this.activeEventData(eventData, true);
}
this.removeSelectedAppointmentClass();
this.parent.selectedElements = [];
if (this.parent.activeEventData.element.classList.contains(cls.INLINE_APPOINTMENT_CLASS) ||
this.parent.activeEventData.element.querySelector('.' + cls.INLINE_SUBJECT_CLASS)) {
return;
}
var args = extend(this.parent.activeEventData, { cancel: false, originalEvent: eventData });
this.parent.trigger(event.eventDoubleClick, args, function (eventDoubleClickArgs) {
if (!eventDoubleClickArgs.cancel) {
if (!isNullOrUndefined(_this.parent.activeEventData.event) &&
isNullOrUndefined(_this.parent.activeEventData.event[_this.parent.eventFields.recurrenceID])) {
_this.parent.eventWindow.openEditor(_this.parent.activeEventData.event, 'Save');
}
else {