@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.
840 lines (839 loc) • 46.3 kB
JavaScript
/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable max-len */
import { isNullOrUndefined, extend, removeClass } from '@syncfusion/ej2-base';
import { getRecurrenceStringFromDate, generate } from '../../recurrence-editor/date-generator';
import * as events from '../base/constant';
import * as util from '../base/util';
/**
* Schedule CRUD operations
*/
var Crud = /** @class */ (function () {
function Crud(parent) {
this.parent = parent;
this.crudObj = { sourceEvent: null, targetEvent: null, isCrudAction: false };
}
Crud.prototype.getQuery = function () {
var start = this.parent.activeView.startDate();
var end = this.parent.activeView.endDate();
return this.parent.dataModule.generateQuery(start, end);
};
Crud.prototype.getTable = function () {
if (this.parent.eventSettings.query) {
var query = this.parent.eventSettings.query.clone();
return query.fromTable;
}
return null;
};
Crud.prototype.refreshDataManager = function () {
var _this = this;
if (!this.parent.activeView) {
return;
}
if (this.parent.uiStateValues && this.parent.uiStateValues.isPreventEventRefresh) {
this.parent.uiStateValues.isPreventEventRefresh = false;
this.parent.refreshEvents(false);
this.parent.hideSpinner();
return;
}
var start = this.parent.activeView.startDate();
var end = this.parent.activeView.endDate();
var dataManager = this.parent.dataModule.getData(this.parent.dataModule.generateQuery(start, end));
dataManager.then(function (e) { return _this.dataManagerSuccess(e); }).catch(function (e) { return _this.dataManagerFailure(e); });
};
Crud.prototype.dataManagerSuccess = function (e) {
var _this = this;
if (!this.parent || this.parent && this.parent.isDestroyed) {
return;
}
this.parent.trigger(events.dataBinding, e, function (args) {
if (args.cancel) {
return;
}
var resultData = extend([], args.result, null, true);
_this.parent.eventsData = resultData.filter(function (data) { return !data[_this.parent.eventFields.isBlock]; });
_this.parent.blockData = resultData.filter(function (data) { return data[_this.parent.eventFields.isBlock]; });
_this.refreshProcessedData();
if (_this.parent.dragAndDropModule && _this.parent.dragAndDropModule.actionObj.action === 'drag') {
_this.parent.dragAndDropModule.navigationWrapper();
}
_this.parent.trigger(events.dataBound, null, function () {
_this.parent.hideSpinner();
if (_this.parent.isPrinting) {
setTimeout(function () {
_this.parent.notify(events.print, {});
}, 100);
}
});
});
};
Crud.prototype.dataManagerFailure = function (e) {
var _this = this;
if (!this.parent || this.parent && this.parent.isDestroyed) {
return;
}
this.parent.trigger(events.actionFailure, { error: e }, function () { return _this.parent.hideSpinner(); });
};
Crud.prototype.refreshProcessedData = function (isVirtualScrollAction, dynamicEvents) {
if (isVirtualScrollAction === void 0) { isVirtualScrollAction = false; }
if (this.parent.dragAndDropModule) {
this.parent.dragAndDropModule.actionObj.action = '';
removeClass([this.parent.element], 'e-event-action');
}
if (this.parent.activeViewOptions && this.parent.activeViewOptions.eventTemplate) {
var templateNames = ['eventTemplate'];
if (this.crudObj.isCrudAction &&
['Agenda', 'MonthAgenda', 'Year', 'TimelineYear'].indexOf(this.parent.currentView) === -1) {
templateNames = [];
for (var i = 0, len = this.crudObj.sourceEvent.length; i < len; i++) {
templateNames.push('eventTemplate_' + this.crudObj.sourceEvent[parseInt(i.toString(), 10)].groupIndex);
if (this.crudObj.targetEvent[parseInt(i.toString(), 10)] && this.crudObj.sourceEvent[parseInt(i.toString(), 10)].groupIndex !==
this.crudObj.targetEvent[parseInt(i.toString(), 10)].groupIndex) {
templateNames.push('eventTemplate_' + this.crudObj.targetEvent[parseInt(i.toString(), 10)].groupIndex);
}
}
}
if (templateNames.length > 0) {
this.parent.resetTemplates(templateNames);
}
}
if (isVirtualScrollAction) {
this.parent.notify(events.dataReady, { processedData: dynamicEvents ? this.parent.eventBase.processData(dynamicEvents) : this.parent.eventsProcessed });
return;
}
var eventsData = this.parent.eventsData || [];
var blockData = this.parent.blockData || [];
var data = eventsData.concat(blockData);
this.parent.notify(events.dataReady, { processedData: this.parent.eventBase ? this.parent.eventBase.processData(data) : [] });
};
Crud.prototype.refreshData = function (args) {
var _this = this;
var actionArgs = {
requestType: args.requestType, cancel: false, data: args.data,
addedRecords: args.editParams.addedRecords, changedRecords: args.editParams.changedRecords,
deletedRecords: args.editParams.deletedRecords
};
if (this.parent.dragAndDropModule && this.parent.dragAndDropModule.actionObj && this.parent.dragAndDropModule.actionObj.element && this.parent.dragAndDropModule.actionObj.action) {
this.parent.dragAndDropModule.actionObj.element.style.display = 'none';
}
if (this.parent.resizeModule && this.parent.resizeModule.actionObj && this.parent.resizeModule.actionObj.element && this.parent.resizeModule.actionObj.action) {
this.parent.resizeModule.actionObj.element.style.display = 'none';
}
if (this.parent.isSpecificResourceEvents()) {
if (args.requestType === 'eventCreated' || args.requestType === 'eventRemoved') {
this.crudObj.isCrudAction = true;
this.crudObj.sourceEvent = [];
var crudData = args.data instanceof Array ? (args.data.length === 0 &&
args.requestType === 'eventRemoved' ? args.editParams.deletedRecords : args.data) :
((typeof args.data === 'string' || typeof args.data === 'number') && args.requestType === 'eventRemoved') ?
args.editParams.deletedRecords : [args.data];
var _loop_1 = function (data) {
this_1.crudObj.isCrudAction = !(args.requestType === 'eventRemoved' && !isNullOrUndefined(data.parent));
var groupIndex = this_1.parent.eventBase.getGroupIndexFromEvent(data);
if (groupIndex > -1 && this_1.parent.crudModule.crudObj.sourceEvent.filter(function (tdData) { return tdData.groupIndex === groupIndex; }).length === 0
&& this_1.crudObj.isCrudAction) {
this_1.crudObj.sourceEvent.push(this_1.parent.resourceBase.lastResourceLevel[parseInt(groupIndex.toString(), 10)]);
}
};
var this_1 = this;
for (var _i = 0, crudData_1 = crudData; _i < crudData_1.length; _i++) {
var data = crudData_1[_i];
_loop_1(data);
}
this.crudObj.targetEvent = this.crudObj.sourceEvent;
}
}
if (this.parent.dataModule.dataManager.dataSource.offline) {
this.parent.trigger(events.actionComplete, actionArgs, function (offlineArgs) {
if (!offlineArgs.cancel) {
_this.refreshDataManager();
}
});
}
else {
args.promise.then(function () {
if (!_this.parent || _this.parent && _this.parent.isDestroyed) {
return;
}
_this.parent.trigger(events.actionComplete, actionArgs, function (onlineArgs) {
if (!onlineArgs.cancel) {
_this.refreshDataManager();
}
});
}).catch(function (e) {
if (!_this.parent || _this.parent && _this.parent.isDestroyed) {
return;
}
_this.parent.trigger(events.actionFailure, { error: e });
});
}
};
Crud.prototype.processAddEvent = function (addArgs) {
var fields = this.parent.eventFields;
var editParams = { addedRecords: [], changedRecords: [], deletedRecords: [] };
var promise;
if (addArgs.addedRecords instanceof Array) {
for (var _i = 0, _a = addArgs.addedRecords; _i < _a.length; _i++) {
var event_1 = _a[_i];
event_1 = this.parent.eventBase.updateEventDateTime(event_1);
var eventData = extend({}, this.parent.eventBase.processTimezone(event_1, true), null, true);
editParams.addedRecords.push(eventData);
}
promise = this.parent.dataModule.dataManager.saveChanges(editParams, fields.id, this.getTable(), this.getQuery());
}
else {
var event_2 = this.parent.eventBase.processTimezone(addArgs.addedRecords, true);
editParams.addedRecords.push(event_2);
promise = this.parent.dataModule.dataManager.insert(event_2, this.getTable(), this.getQuery());
}
var crudArgs = {
requestType: 'eventCreated', cancel: false, data: addArgs.addedRecords, promise: promise, editParams: editParams
};
this.refreshData(crudArgs);
};
Crud.prototype.processSaveEvent = function (saveArgs) {
var promise;
var fields = this.parent.eventFields;
var editParams = { addedRecords: [], changedRecords: [], deletedRecords: [] };
if (saveArgs.changedRecords instanceof Array) {
for (var _i = 0, _a = saveArgs.changedRecords; _i < _a.length; _i++) {
var event_3 = _a[_i];
event_3 = this.parent.eventBase.updateEventDateTime(event_3);
var eventData = extend({}, this.parent.eventBase.processTimezone(event_3, true), null, true);
editParams.changedRecords.push(eventData);
}
promise = this.parent.dataModule.dataManager.saveChanges(editParams, fields.id, this.getTable(), this.getQuery());
}
else {
var event_4 = this.parent.eventBase.processTimezone(saveArgs.changedRecords, true);
editParams.changedRecords.push(event_4);
promise = this.parent.dataModule.dataManager.update(fields.id, event_4, this.getTable(), this.getQuery());
}
var cloneEvent = extend({}, saveArgs.changedRecords[saveArgs.changedRecords.length - 1], null, true);
this.parent.eventBase.selectWorkCellByTime([this.parent.eventBase.processTimezone(cloneEvent)]);
var crudArgs = {
requestType: 'eventChanged', cancel: false,
data: saveArgs.changedRecords, promise: promise, editParams: editParams
};
this.refreshData(crudArgs);
};
Crud.prototype.processDeleteEvent = function (deleteArgs) {
var promise;
var fields = this.parent.eventFields;
var editParams = { addedRecords: [], changedRecords: [], deletedRecords: [] };
if (deleteArgs.deletedRecords.length > 1) {
editParams.deletedRecords = editParams.deletedRecords.concat(deleteArgs.deletedRecords);
promise = this.parent.dataModule.dataManager.saveChanges(editParams, fields.id, this.getTable(), this.getQuery());
}
else {
editParams.deletedRecords.push(deleteArgs.deletedRecords[0]);
promise = this.parent.dataModule.dataManager.remove(fields.id, deleteArgs.deletedRecords[0], this.getTable(), this.getQuery());
}
this.parent.eventBase.selectWorkCellByTime(deleteArgs.deletedRecords);
var crudArgs = {
requestType: 'eventRemoved', cancel: false,
data: deleteArgs.deletedRecords, promise: promise, editParams: editParams
};
this.refreshData(crudArgs);
};
Crud.prototype.addEvent = function (eventData) {
var _this = this;
if (this.parent.eventSettings.allowAdding && !this.parent.activeViewOptions.readonly) {
if (!this.isBlockEvent(eventData) && this.parent.eventBase.isBlockRange(eventData)) {
this.parent.quickPopup.openValidationError('blockAlert', eventData);
return;
}
if (this.parent.eventBase.checkOverlap(eventData)) {
return;
}
var addEvents = (eventData instanceof Array) ? eventData : [eventData];
if (addEvents.length === 0) {
return;
}
var args = {
requestType: 'eventCreate', cancel: false, data: addEvents,
addedRecords: addEvents, changedRecords: [], deletedRecords: []
};
this.parent.trigger(events.actionBegin, args, function (addArgs) {
if (!addArgs.cancel) {
if (addArgs.promise) {
addArgs.promise.then(function (hasContinue) {
if (!_this.parent || _this.parent && _this.parent.isDestroyed) {
return;
}
if (hasContinue) {
_this.processAddEvent(addArgs);
}
}).catch(function (e) {
if (!_this.parent || _this.parent && _this.parent.isDestroyed) {
return;
}
_this.parent.trigger(events.actionFailure, { error: e });
});
}
else {
_this.processAddEvent(addArgs);
}
}
});
}
};
Crud.prototype.saveEvent = function (eventData, action) {
var _this = this;
if (this.parent.eventSettings.allowEditing && !this.parent.activeViewOptions.readonly) {
if (this.parent.currentAction !== 'EditFollowingEvents' && !this.isBlockEvent(eventData)
&& this.parent.eventBase.isBlockRange(eventData)) {
this.parent.quickPopup.openValidationError('blockAlert', eventData);
this.parent.crudModule.crudObj.isCrudAction = false;
return;
}
var updateEvents = (eventData instanceof Array) ? eventData : [eventData];
if (updateEvents.length === 0) {
return;
}
this.parent.currentAction = action;
if (action) {
switch (action) {
case 'Save':
this.processSave(eventData);
break;
case 'EditOccurrence':
this.processOccurrences(eventData, action);
break;
case 'EditFollowingEvents':
this.processFollowSeries(eventData, action);
break;
case 'EditSeries':
this.processEntireSeries(eventData, action);
break;
}
}
else {
if (this.parent.eventBase.checkOverlap(eventData)) {
return;
}
var args = {
requestType: 'eventChange', cancel: false, data: eventData,
addedRecords: [], changedRecords: updateEvents, deletedRecords: []
};
this.parent.trigger(events.actionBegin, args, function (saveArgs) {
if (!saveArgs.cancel) {
if (saveArgs.promise) {
saveArgs.promise.then(function (hasContinue) {
if (!_this.parent || _this.parent && _this.parent.isDestroyed) {
return;
}
if (hasContinue) {
_this.processSaveEvent(saveArgs);
}
}).catch(function (e) {
if (!_this.parent || _this.parent && _this.parent.isDestroyed) {
return;
}
_this.parent.trigger(events.actionFailure, { error: e });
});
}
else {
_this.processSaveEvent(saveArgs);
}
}
});
}
}
};
Crud.prototype.deleteEvent = function (eventData, action) {
var _this = this;
if (this.parent.eventSettings.allowDeleting && !this.parent.activeViewOptions.readonly) {
this.parent.currentAction = action;
var deleteEvents = [];
if (typeof eventData === 'string' || typeof eventData === 'number') {
deleteEvents = this.parent.eventsData.filter(function (eventObj) {
return eventObj[_this.parent.eventFields.id] === eventData;
});
}
else {
deleteEvents = (eventData instanceof Array ? eventData : [eventData]);
}
if (deleteEvents.length === 0) {
return;
}
if (action) {
switch (action) {
case 'Delete':
this.processDelete(deleteEvents);
break;
case 'DeleteOccurrence':
this.processOccurrences(deleteEvents, action);
break;
case 'DeleteFollowingEvents':
this.processFollowSeries(deleteEvents, action);
break;
case 'DeleteSeries':
this.processEntireSeries(deleteEvents, action);
break;
}
}
else {
var args = {
requestType: 'eventRemove', cancel: false, data: eventData,
addedRecords: [], changedRecords: [], deletedRecords: deleteEvents
};
this.parent.trigger(events.actionBegin, args, function (deleteArgs) {
if (!deleteArgs.cancel) {
if (deleteArgs.promise) {
deleteArgs.promise.then(function (hasContinue) {
if (!_this.parent || _this.parent && _this.parent.isDestroyed) {
return;
}
if (hasContinue) {
_this.processDeleteEvent(deleteArgs);
}
}).catch(function (e) {
if (!_this.parent || _this.parent && _this.parent.isDestroyed) {
return;
}
_this.parent.trigger(events.actionFailure, { error: e });
});
}
else {
_this.processDeleteEvent(deleteArgs);
}
}
});
}
}
};
Crud.prototype.processOccurrences = function (eventData, action) {
var _this = this;
var occurrenceData = [];
var isDeletedRecords = false;
if (eventData instanceof Array) {
for (var _i = 0, eventData_1 = eventData; _i < eventData_1.length; _i++) {
var event_5 = eventData_1[_i];
occurrenceData.push({ occurrence: event_5, parent: this.getParentEvent(event_5) });
}
}
else {
occurrenceData = { occurrence: eventData, parent: this.getParentEvent(eventData) };
}
var updateEvents = (eventData instanceof Array) ? eventData : [eventData];
var args = {
requestType: action === 'EditOccurrence' ? 'eventChange' : 'eventRemove',
cancel: false,
addedRecords: [], changedRecords: updateEvents, deletedRecords: []
};
args.data = occurrenceData;
this.parent.trigger(events.actionBegin, args, function (occurrenceArgs) {
if (!occurrenceArgs.cancel) {
var fields = _this.parent.eventFields;
var editParams = { addedRecords: [], changedRecords: [], deletedRecords: [] };
var occurrenceEvents = (occurrenceData instanceof Array ? occurrenceData : [occurrenceData]);
var _loop_2 = function (a, count) {
var childEvent = occurrenceArgs.changedRecords[parseInt(a.toString(), 10)];
var parentEvent = occurrenceEvents[parseInt(a.toString(), 10)].parent;
var parentException = parentEvent[fields.recurrenceException];
var editedData = void 0;
var exceptionDate = void 0;
switch (action) {
case 'EditOccurrence':
editedData = _this.parent.eventsProcessed.filter(function (event) { return event.Guid === childEvent.Guid; })[0];
exceptionDate = _this.excludeDateCheck(editedData[fields.startTime], parentException);
if (exceptionDate !== parentEvent[fields.recurrenceException]) {
parentEvent[fields.recurrenceException] = exceptionDate;
childEvent[fields.recurrenceException] = getRecurrenceStringFromDate(editedData[fields.startTime]);
childEvent[fields.recurrenceID] = parentEvent[fields.id];
childEvent[fields.followingID] = null;
editParams.changedRecords.push(_this.parent.eventBase.processTimezone(parentEvent, true));
editParams.addedRecords.push(_this.parent.eventBase.processTimezone(childEvent, true));
}
else {
editParams.changedRecords.push(_this.parent.eventBase.processTimezone(childEvent, true));
}
break;
case 'DeleteOccurrence':
if (!childEvent[fields.recurrenceException]) {
parentEvent[fields.recurrenceException] =
_this.excludeDateCheck(childEvent[fields.startTime], parentException);
editParams.changedRecords.push(_this.parent.eventBase.processTimezone(parentEvent, true));
}
if (childEvent[fields.id] !== parentEvent[fields.id]) {
editParams.deletedRecords.push(_this.parent.eventBase.processTimezone(childEvent, true));
isDeletedRecords = true;
}
break;
}
};
for (var a = 0, count = occurrenceArgs.changedRecords.length; a < count; a++) {
_loop_2(a, count);
}
var promise = _this.parent.dataModule.dataManager.saveChanges(editParams, fields.id, _this.getTable(), _this.getQuery());
var cloneEvent = extend({}, occurrenceArgs.changedRecords[occurrenceArgs.changedRecords.length - 1], null, true);
_this.parent.eventBase.selectWorkCellByTime(action === 'EditOccurrence' ? [_this.parent.eventBase.processTimezone(cloneEvent)] : [cloneEvent]);
var crudArgs = {
requestType: action === 'EditOccurrence' ? 'eventChanged' : 'eventRemoved',
cancel: false, data: isDeletedRecords ? occurrenceArgs.deletedRecords : occurrenceArgs.changedRecords,
promise: promise, editParams: editParams
};
_this.refreshData(crudArgs);
}
});
};
Crud.prototype.processFollowSeries = function (eventData, action) {
var _this = this;
var followData = [];
if (eventData instanceof Array) {
for (var _i = 0, eventData_2 = eventData; _i < eventData_2.length; _i++) {
var event_6 = eventData_2[_i];
followData.push({ occurrence: event_6, parent: this.getParentEvent(event_6) });
}
}
else {
followData = { occurrence: eventData, parent: this.getParentEvent(eventData) };
}
var updateFollowEvents = (eventData instanceof Array) ? eventData : [eventData];
var args = {
requestType: action === 'EditFollowingEvents' ? 'eventChange' : 'eventRemove', cancel: false,
addedRecords: [], changedRecords: updateFollowEvents, deletedRecords: []
};
args.data = followData;
this.parent.trigger(events.actionBegin, args, function (followArgs) {
if (!followArgs.cancel) {
var fields_1 = _this.parent.eventFields;
var editParams = { addedRecords: [], changedRecords: [], deletedRecords: [] };
var followEvents = followData instanceof Array ? followData : [followData];
var _loop_3 = function (a, count) {
var childEvent = followArgs.changedRecords[parseInt(a.toString(), 10)];
var parentEvent = followEvents[parseInt(a.toString(), 10)].parent;
var followData_1 = _this.parent.eventBase.getEventCollections(parentEvent, childEvent);
var isSpanned = void 0;
switch (action) {
case 'EditFollowingEvents':
_this.processRecurrenceRule(parentEvent, childEvent);
isSpanned = !_this.parent.eventBase.isFollowingEvent(parentEvent, childEvent);
childEvent[fields_1.followingID] = isSpanned ? null : parentEvent[fields_1.id];
childEvent[fields_1.recurrenceID] = null;
editParams.addedRecords.push(_this.parent.eventBase.processTimezone(childEvent, true));
editParams.changedRecords.push(_this.parent.eventBase.processTimezone(parentEvent, true));
if (!_this.parent.uiStateValues.isIgnoreOccurrence) {
childEvent[fields_1.recurrenceException] = null;
if (followData_1.occurrence.length > 0) {
var rule = followData_1.occurrence.slice(-1)[0][fields_1.recurrenceRule];
if (rule.indexOf('COUNT') === -1) {
childEvent[fields_1.recurrenceRule] = rule;
}
}
if (followData_1.follow.length > 0) {
childEvent[fields_1.recurrenceRule] = followData_1.follow.slice(-1)[0][fields_1.recurrenceRule];
editParams.deletedRecords = editParams.deletedRecords.concat(followData_1.follow);
}
if (isSpanned) {
followData_1.occurrence = followData_1.occurrence.filter(function (eventObj) {
return eventObj[fields_1.recurrenceID] === parentEvent[fields_1.id];
});
}
editParams.deletedRecords = editParams.deletedRecords.concat(followData_1.occurrence);
}
break;
case 'DeleteFollowingEvents':
_this.processRecurrenceRule(parentEvent, childEvent[fields_1.startTime]);
editParams.changedRecords.push(_this.parent.eventBase.processTimezone(parentEvent, true));
editParams.deletedRecords = editParams.deletedRecords.concat(followData_1.occurrence).concat(followData_1.follow);
break;
}
};
for (var a = 0, count = followArgs.changedRecords.length; a < count; a++) {
_loop_3(a, count);
}
var promise = _this.parent.dataModule.dataManager.saveChanges(editParams, fields_1.id, _this.getTable(), _this.getQuery());
var cloneEvent = extend({}, followArgs.changedRecords[followArgs.changedRecords.length - 1], null, true);
_this.parent.eventBase.selectWorkCellByTime(action === 'EditFollowingEvents' ? [_this.parent.eventBase.processTimezone(cloneEvent)] : [cloneEvent]);
var crudArgs = {
requestType: action === 'EditFollowingEvents' ? 'eventChanged' : 'eventRemoved',
cancel: false, data: followArgs.changedRecords, promise: promise, editParams: editParams
};
_this.refreshData(crudArgs);
}
});
};
Crud.prototype.processEntireSeries = function (eventData, action) {
var _this = this;
var seriesData = [];
var isDeletedRecords = false;
if (eventData instanceof Array) {
for (var _i = 0, eventData_3 = eventData; _i < eventData_3.length; _i++) {
var event_7 = eventData_3[_i];
seriesData.push(this.getParentEvent(event_7, true));
}
}
else {
seriesData = this.getParentEvent(eventData, true);
}
var updateSeriesEvents = (eventData instanceof Array) ? eventData : [eventData];
var args = {
requestType: action === 'EditSeries' ? 'eventChange' : 'eventRemove', cancel: false,
addedRecords: [], changedRecords: [], deletedRecords: []
};
args.data = seriesData;
if (action === 'EditSeries') {
args.changedRecords = updateSeriesEvents;
}
else {
args.deletedRecords = updateSeriesEvents;
}
if (action === 'EditSeries' && !this.parent.uiStateValues.isIgnoreOccurrence) {
var seriesEvents = seriesData instanceof Array ? seriesData : [seriesData];
for (var a = 0, count = args.changedRecords.length; a < count; a++) {
var parentEvent = seriesEvents[parseInt(a.toString(), 10)];
var eventCollections = this.parent.eventBase.getEventCollections(parentEvent);
var deletedEvents = eventCollections.follow.concat(eventCollections.occurrence);
args.deletedRecords = args.deletedRecords.concat(deletedEvents);
}
}
this.parent.trigger(events.actionBegin, args, function (seriesArgs) {
if (!seriesArgs.cancel) {
var fields_2 = _this.parent.eventFields;
var editParams = { addedRecords: [], changedRecords: [], deletedRecords: [] };
var seriesEvents = seriesData instanceof Array ? seriesData : [seriesData];
var records = action === 'EditSeries' ? seriesArgs.changedRecords : seriesArgs.deletedRecords;
var _loop_4 = function (a, count) {
var childEvent = records[parseInt(a.toString(), 10)];
var parentEvent = seriesEvents[parseInt(a.toString(), 10)];
var eventCollections = _this.parent.eventBase.getEventCollections(parentEvent);
var deletedEvents = eventCollections.follow.concat(eventCollections.occurrence);
switch (action) {
case 'EditSeries':
childEvent[fields_2.id] = parentEvent[fields_2.id];
childEvent[fields_2.recurrenceID] = null;
childEvent[fields_2.followingID] = null;
if (_this.parent.uiStateValues.isIgnoreOccurrence && childEvent[fields_2.recurrenceException]) {
var originalParent = _this.parent.eventsData.filter(function (eventObj) {
return eventObj[fields_2.id] === childEvent[fields_2.id];
});
if (originalParent.length > 0) {
childEvent[fields_2.recurrenceRule] = originalParent[0][fields_2.recurrenceRule];
}
}
else {
childEvent[fields_2.recurrenceException] = null;
editParams.deletedRecords = editParams.deletedRecords.concat(deletedEvents);
}
editParams.changedRecords.push(_this.parent.eventBase.processTimezone(childEvent, true));
_this.parent.uiStateValues.isIgnoreOccurrence = false;
break;
case 'DeleteSeries':
editParams.deletedRecords = editParams.deletedRecords.concat(deletedEvents.concat(_this.parent.eventBase.processTimezone(parentEvent, true)));
isDeletedRecords = true;
break;
}
};
for (var a = 0, count = records.length; a < count; a++) {
_loop_4(a, count);
}
var promise = _this.parent.dataModule.dataManager.saveChanges(editParams, fields_2.id, _this.getTable(), _this.getQuery());
var cloneEvent = extend({}, records[records.length - 1], null, true);
_this.parent.eventBase.selectWorkCellByTime(action === 'EditSeries' ? [_this.parent.eventBase.processTimezone(cloneEvent)] : [cloneEvent]);
var crudArgs = {
requestType: action === 'EditSeries' ? 'eventChanged' : 'eventRemoved',
cancel: false, data: isDeletedRecords ? seriesArgs.deletedRecords : seriesArgs.changedRecords,
promise: promise, editParams: editParams
};
_this.refreshData(crudArgs);
}
});
};
Crud.prototype.processDelete = function (eventData) {
var _this = this;
var deleteData = [];
for (var _i = 0, eventData_4 = eventData; _i < eventData_4.length; _i++) {
var eventObj = eventData_4[_i];
if (eventObj[this.parent.eventFields.recurrenceRule]) {
deleteData.push({ occurrence: eventObj, parent: this.getParentEvent(eventObj) });
}
else {
deleteData.push(eventObj);
}
}
var args = {
requestType: 'eventRemove', cancel: false,
addedRecords: [], changedRecords: [], deletedRecords: eventData
};
args.data = deleteData;
this.parent.trigger(events.actionBegin, args, function (deleteArgs) {
if (!deleteArgs.cancel) {
var fields_3 = _this.parent.eventFields;
var editParams = { addedRecords: [], changedRecords: [], deletedRecords: [] };
var cloneEvents = extend([], deleteArgs.deletedRecords, null, true);
var _loop_5 = function (a, count) {
var isDelete = isNullOrUndefined(deleteArgs.deletedRecords[parseInt(a.toString(), 10)][_this.parent.eventFields.recurrenceRule]);
if (!isDelete) {
var parentEvent_1 = deleteData[parseInt(a.toString(), 10)].parent;
var isEdited = editParams.changedRecords.filter(function (obj) {
return obj[fields_3.id] === parentEvent_1[fields_3.id];
});
var editedDate = deleteArgs.deletedRecords[parseInt(a.toString(), 10)][fields_3.startTime];
if (isEdited.length > 0) {
var editedData = isEdited[0];
editedData[fields_3.recurrenceException] =
_this.excludeDateCheck(editedDate, editedData[fields_3.recurrenceException]);
}
else {
parentEvent_1[fields_3.recurrenceException] =
_this.excludeDateCheck(editedDate, parentEvent_1[fields_3.recurrenceException]);
}
if (isEdited.length === 0) {
editParams.changedRecords.push(_this.parent.eventBase.processTimezone(parentEvent_1, true));
}
isDelete = deleteArgs.deletedRecords[parseInt(a.toString(), 10)][fields_3.id] !== parentEvent_1[fields_3.id];
}
if (isDelete) {
if (deleteArgs.deletedRecords instanceof Array) {
for (var _i = 0, _a = deleteArgs.deletedRecords; _i < _a.length; _i++) {
var event_8 = _a[_i];
_this.parent.eventBase.processTimezone(event_8, true);
}
}
editParams.deletedRecords.push(deleteArgs.deletedRecords[parseInt(a.toString(), 10)]);
}
};
for (var a = 0, count = deleteArgs.deletedRecords.length; a < count; a++) {
_loop_5(a, count);
}
var promise = _this.parent.dataModule.dataManager.saveChanges(editParams, fields_3.id, _this.getTable(), _this.getQuery());
_this.parent.eventBase.selectWorkCellByTime(cloneEvents);
var crudArgs = {
requestType: 'eventRemoved', cancel: false, data: deleteArgs.deletedRecords, promise: promise, editParams: editParams
};
_this.refreshData(crudArgs);
}
});
};
Crud.prototype.processSave = function (data) {
var _this = this;
var eventData = (data instanceof Array) ? data : [data];
var editData = [];
for (var _i = 0, eventData_5 = eventData; _i < eventData_5.length; _i++) {
var eventObj = eventData_5[_i];
if (eventObj[this.parent.eventFields.recurrenceRule]) {
editData.push({ occurrence: eventObj, parent: this.getParentEvent(eventObj) });
}
else {
editData.push(eventObj);
}
}
var args = { requestType: 'eventChange', cancel: false, addedRecords: [], changedRecords: eventData, deletedRecords: [] };
args.data = editData;
this.parent.trigger(events.actionBegin, args, function (editArgs) {
if (!editArgs.cancel) {
var fields = _this.parent.eventFields;
var editParams = { addedRecords: [], changedRecords: [], deletedRecords: [] };
for (var _i = 0, _a = editArgs.changedRecords; _i < _a.length; _i++) {
var record = _a[_i];
if (!isNullOrUndefined(record[fields.recurrenceRule]) && isNullOrUndefined(record[fields.recurrenceException])) {
var exceptionString = getRecurrenceStringFromDate(record[fields.startTime]);
var parentEle = _this.getParentEvent(record);
parentEle[fields.recurrenceException] = isNullOrUndefined(parentEle[fields.recurrenceException]) ?
exceptionString : parentEle[fields.recurrenceException].concat(',' + exceptionString);
record[fields.id] = _this.parent.getEventMaxID();
record[fields.recurrenceException] = exceptionString;
editParams.addedRecords.push(_this.parent.eventBase.processTimezone(record, true));
editParams.changedRecords.push(_this.parent.eventBase.processTimezone(parentEle, true));
}
else {
editParams.changedRecords.push(_this.parent.eventBase.processTimezone(record, true));
}
}
var promise = _this.parent.dataModule.dataManager.saveChanges(editParams, fields.id, _this.getTable(), _this.getQuery());
var cloneEvent = extend({}, editArgs.changedRecords[editArgs.changedRecords.length - 1], null, true);
_this.parent.eventBase.selectWorkCellByTime([_this.parent.eventBase.processTimezone(cloneEvent)]);
var crudArgs = { requestType: 'eventChanged', cancel: false, data: editArgs.changedRecords, promise: promise, editParams: editParams };
_this.refreshData(crudArgs);
}
});
};
Crud.prototype.getParentEvent = function (event, isParent) {
if (isParent === void 0) { isParent = false; }
var parentEvent = this.parent.eventBase.getParentEvent(event, isParent) || event;
if (parentEvent[this.parent.eventFields.startTimezone] || parentEvent[this.parent.eventFields.endTimezone]) {
this.parent.eventBase.timezoneConvert(parentEvent);
}
return parentEvent;
};
Crud.prototype.excludeDateCheck = function (eventStartTime, exceptionDateList) {
var timezone = this.parent.timezone || this.parent.tzModule.getLocalTimezoneName();
if (timezone) {
eventStartTime = this.parent.tzModule.remove(new Date(+eventStartTime.getTime()), timezone);
}
var exDate = getRecurrenceStringFromDate(eventStartTime);
if (!isNullOrUndefined(exceptionDateList)) {
if (exceptionDateList.indexOf(exDate) === -1) {
exceptionDateList = !(isNullOrUndefined(exceptionDateList)) ? exceptionDateList + ',' + exDate : exDate;
}
}
else {
exceptionDateList = exDate;
}
return exceptionDateList;
};
Crud.prototype.processRecurrenceRule = function (parentEvent, followEvent) {
var fields = this.parent.eventFields;
var recurrenceRule = parentEvent[fields.recurrenceRule];
var endDate;
if (followEvent instanceof Date) {
endDate = new Date(+followEvent);
}
else {
endDate = new Date(+followEvent[fields.startTime]);
var newRecurrenceRule = followEvent[fields.recurrenceRule];
if (newRecurrenceRule) {
var startDate = parentEvent[fields.startTime];
var ruleException = (this.parent.currentAction === 'DeleteFollowingEvents') ? followEvent[fields.recurrenceException] : null;
var dateCollection = generate(startDate, newRecurrenceRule, ruleException, this.parent.activeViewOptions.firstDayOfWeek);
var untilDate = new Date(dateCollection.slice(-1)[0]);
untilDate.setHours(endDate.getHours(), endDate.getMinutes(), endDate.getSeconds());
endDate.setHours(startDate.getHours(), startDate.getMinutes(), startDate.getSeconds());
followEvent[fields.recurrenceRule] = this.getUpdatedRecurrenceRule(newRecurrenceRule, new Date(+untilDate), false);
}
}
parentEvent[fields.recurrenceRule] = this.getUpdatedRecurrenceRule(recurrenceRule, util.addDays(new Date(endDate.getTime()), -1), true);
};
Crud.prototype.getUpdatedRecurrenceRule = function (recurrenceRule, untilDate, isParent) {
var splitRule = recurrenceRule.split(';');
var updatedRule = '';
for (var _i = 0, splitRule_1 = splitRule; _i < splitRule_1.length; _i++) {
var rule = splitRule_1[_i];
if (rule !== '') {
var ruleKey = rule.split('=')[0];
var ruleValue = rule.split('=')[1];
if (ruleKey === 'COUNT' || ruleKey === 'UNTIL') {
ruleValue = getRecurrenceStringFromDate(untilDate);
rule = rule.replace(rule, 'UNTIL=' + ruleValue);
}
updatedRule += rule + ';';
}
}
if (isParent && updatedRule.indexOf('UNTIL') === -1) {
updatedRule += 'UNTIL=' + getRecurrenceStringFromDate(untilDate);
}
return updatedRule;
};
Crud.prototype.isBlockEvent = function (eventData) {
var eventCollection = (eventData instanceof Array) ? eventData : [eventData];
var value = false;
for (var _i = 0, eventCollection_1 = eventCollection; _i < eventCollection_1.length; _i++) {
var event_9 = eventCollection_1[_i];
value = event_9[this.parent.eventFields.isBlock] || false;
}
return value;
};
/**
* To destroy the crud module.
*
* @returns {void}
* @private
*/
Crud.prototype.destroy = function () {
this.crudObj = null;
this.parent = null;
};
return Crud;
}());
export { Crud };