392 lines
9.2 KiB
JavaScript
392 lines
9.2 KiB
JavaScript
|
|
fc.sourceNormalizers = [];
|
|
fc.sourceFetchers = [];
|
|
|
|
var ajaxDefaults = {
|
|
dataType: 'json',
|
|
cache: false
|
|
};
|
|
|
|
var eventGUID = 1;
|
|
|
|
|
|
function EventManager(options, _sources) {
|
|
var t = this;
|
|
|
|
|
|
// exports
|
|
t.isFetchNeeded = isFetchNeeded;
|
|
t.fetchEvents = fetchEvents;
|
|
t.addEventSource = addEventSource;
|
|
t.removeEventSource = removeEventSource;
|
|
t.updateEvent = updateEvent;
|
|
t.renderEvent = renderEvent;
|
|
t.removeEvents = removeEvents;
|
|
t.clientEvents = clientEvents;
|
|
t.normalizeEvent = normalizeEvent;
|
|
|
|
|
|
// imports
|
|
var trigger = t.trigger;
|
|
var getView = t.getView;
|
|
var reportEvents = t.reportEvents;
|
|
|
|
|
|
// locals
|
|
var stickySource = { events: [] };
|
|
var sources = [ stickySource ];
|
|
var rangeStart, rangeEnd;
|
|
var currentFetchID = 0;
|
|
var pendingSourceCnt = 0;
|
|
var loadingLevel = 0;
|
|
var cache = [];
|
|
|
|
|
|
for (var i=0; i<_sources.length; i++) {
|
|
_addEventSource(_sources[i]);
|
|
}
|
|
|
|
|
|
|
|
/* Fetching
|
|
-----------------------------------------------------------------------------*/
|
|
|
|
|
|
function isFetchNeeded(start, end) {
|
|
return !rangeStart || start < rangeStart || end > rangeEnd;
|
|
}
|
|
|
|
|
|
function fetchEvents(start, end) {
|
|
rangeStart = start;
|
|
rangeEnd = end;
|
|
cache = [];
|
|
var fetchID = ++currentFetchID;
|
|
var len = sources.length;
|
|
pendingSourceCnt = len;
|
|
for (var i=0; i<len; i++) {
|
|
fetchEventSource(sources[i], fetchID);
|
|
}
|
|
}
|
|
|
|
|
|
function fetchEventSource(source, fetchID) {
|
|
_fetchEventSource(source, function(events) {
|
|
if (fetchID == currentFetchID) {
|
|
if (events) {
|
|
for (var i=0; i<events.length; i++) {
|
|
events[i].source = source;
|
|
normalizeEvent(events[i]);
|
|
}
|
|
cache = cache.concat(events);
|
|
}
|
|
pendingSourceCnt--;
|
|
if (!pendingSourceCnt) {
|
|
reportEvents(cache);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
function _fetchEventSource(source, callback) {
|
|
var i;
|
|
var fetchers = fc.sourceFetchers;
|
|
var res;
|
|
for (i=0; i<fetchers.length; i++) {
|
|
res = fetchers[i](source, rangeStart, rangeEnd, callback);
|
|
if (res === true) {
|
|
// the fetcher is in charge. made its own async request
|
|
return;
|
|
}
|
|
else if (typeof res == 'object') {
|
|
// the fetcher returned a new source. process it
|
|
_fetchEventSource(res, callback);
|
|
return;
|
|
}
|
|
}
|
|
var events = source.events;
|
|
if (events) {
|
|
if ($.isFunction(events)) {
|
|
pushLoading();
|
|
events(cloneDate(rangeStart), cloneDate(rangeEnd), function(events) {
|
|
callback(events);
|
|
popLoading();
|
|
});
|
|
}
|
|
else if ($.isArray(events)) {
|
|
callback(events);
|
|
}
|
|
else {
|
|
callback();
|
|
}
|
|
}else{
|
|
var url = source.url;
|
|
var eventTransform = source.eventTransform || options.eventTransform;
|
|
if (url) {
|
|
var success = source.success;
|
|
var error = source.error;
|
|
var complete = source.complete;
|
|
var data = $.extend({}, source.data || {});
|
|
var startParam = firstDefined(source.startParam, options.startParam);
|
|
var endParam = firstDefined(source.endParam, options.endParam);
|
|
if (startParam) {
|
|
data[startParam] = (options.startEndDateOnly) ? (rangeStart.getYear()+'-'+(rangeStart.getMonth()+1)+'-'+rangeStart.getDate()) : Math.round(+rangeStart / 1000);
|
|
}
|
|
if (endParam) {
|
|
data[endParam] = (options.startEndDateOnly) ? (rangeEnd.getYear()+'-'+(rangeEnd.getMonth()+1)+'-'+rangeEnd.getDate()) : Math.round(+rangeEnd / 1000);
|
|
}
|
|
pushLoading();
|
|
$.ajax($.extend({}, ajaxDefaults, source, {
|
|
data: data,
|
|
success: function(events) {
|
|
events = events || [];
|
|
var res = applyAll(success, this, arguments);
|
|
if ($.isArray(res)) {
|
|
events = res;
|
|
}
|
|
callback(events && eventTransform
|
|
? $.map(events, eventTransform)
|
|
: events);
|
|
},
|
|
error: function() {
|
|
applyAll(error, this, arguments);
|
|
callback();
|
|
},
|
|
complete: function() {
|
|
applyAll(complete, this, arguments);
|
|
popLoading();
|
|
}
|
|
}));
|
|
}else{
|
|
callback();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/* Sources
|
|
-----------------------------------------------------------------------------*/
|
|
|
|
|
|
function addEventSource(source) {
|
|
source = _addEventSource(source);
|
|
if (source) {
|
|
pendingSourceCnt++;
|
|
fetchEventSource(source, currentFetchID); // will eventually call reportEvents
|
|
}
|
|
}
|
|
|
|
|
|
function _addEventSource(source) {
|
|
if ($.isFunction(source) || $.isArray(source)) {
|
|
source = { events: source };
|
|
}
|
|
else if (typeof source == 'string') {
|
|
source = { url: source };
|
|
}
|
|
if (typeof source == 'object') {
|
|
normalizeSource(source);
|
|
sources.push(source);
|
|
return source;
|
|
}
|
|
}
|
|
|
|
|
|
function removeEventSource(source) {
|
|
sources = $.grep(sources, function(src) {
|
|
return !isSourcesEqual(src, source);
|
|
});
|
|
// remove all client events from that source
|
|
cache = $.grep(cache, function(e) {
|
|
return !isSourcesEqual(e.source, source);
|
|
});
|
|
reportEvents(cache);
|
|
}
|
|
|
|
|
|
|
|
/* Manipulation
|
|
-----------------------------------------------------------------------------*/
|
|
|
|
|
|
function updateEvent(event) { // update an existing event
|
|
var i, len = cache.length, e,
|
|
defaultEventEnd = getView().defaultEventEnd, // getView???
|
|
startDelta = event.start - event._start,
|
|
endDelta = event.end ?
|
|
(event.end - (event._end || defaultEventEnd(event))) // event._end would be null if event.end
|
|
: 0; // was null and event was just resized
|
|
for (i=0; i<len; i++) {
|
|
e = cache[i];
|
|
if (e._id == event._id && e != event) {
|
|
e.start = new Date(+e.start + startDelta);
|
|
if (event.end) {
|
|
if (e.end) {
|
|
e.end = new Date(+e.end + endDelta);
|
|
}else{
|
|
e.end = new Date(+defaultEventEnd(e) + endDelta);
|
|
}
|
|
}else{
|
|
e.end = null;
|
|
}
|
|
e.title = event.title;
|
|
e.url = event.url;
|
|
e.allDay = event.allDay;
|
|
e.className = event.className;
|
|
e.editable = event.editable;
|
|
e.color = event.color;
|
|
e.backgroundColor = event.backgroundColor;
|
|
e.borderColor = event.borderColor;
|
|
e.textColor = event.textColor;
|
|
normalizeEvent(e);
|
|
}
|
|
}
|
|
normalizeEvent(event);
|
|
reportEvents(cache);
|
|
}
|
|
|
|
|
|
function renderEvent(event, stick) {
|
|
normalizeEvent(event);
|
|
if (!event.source) {
|
|
if (stick) {
|
|
stickySource.events.push(event);
|
|
event.source = stickySource;
|
|
}
|
|
cache.push(event);
|
|
}
|
|
reportEvents(cache);
|
|
}
|
|
|
|
|
|
function removeEvents(filter) {
|
|
if (!filter) { // remove all
|
|
cache = [];
|
|
// clear all array sources
|
|
for (var i=0; i<sources.length; i++) {
|
|
if ($.isArray(sources[i].events)) {
|
|
sources[i].events = [];
|
|
}
|
|
}
|
|
}else{
|
|
if (!$.isFunction(filter)) { // an event ID
|
|
var id = filter + '';
|
|
filter = function(e) {
|
|
return e._id == id;
|
|
};
|
|
}
|
|
cache = $.grep(cache, filter, true);
|
|
// remove events from array sources
|
|
for (var i=0; i<sources.length; i++) {
|
|
if ($.isArray(sources[i].events)) {
|
|
sources[i].events = $.grep(sources[i].events, filter, true);
|
|
}
|
|
}
|
|
}
|
|
reportEvents(cache);
|
|
}
|
|
|
|
|
|
function clientEvents(filter) {
|
|
if ($.isFunction(filter)) {
|
|
return $.grep(cache, filter);
|
|
}
|
|
else if (filter) { // an event ID
|
|
filter += '';
|
|
return $.grep(cache, function(e) {
|
|
return e._id == filter;
|
|
});
|
|
}
|
|
return cache; // else, return all
|
|
}
|
|
|
|
|
|
|
|
/* Loading State
|
|
-----------------------------------------------------------------------------*/
|
|
|
|
|
|
function pushLoading() {
|
|
if (!loadingLevel++) {
|
|
trigger('loading', null, true);
|
|
}
|
|
}
|
|
|
|
|
|
function popLoading() {
|
|
if (!--loadingLevel) {
|
|
trigger('loading', null, false);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/* Event Normalization
|
|
-----------------------------------------------------------------------------*/
|
|
|
|
|
|
function normalizeEvent(event) {
|
|
var source = event.source || {};
|
|
var ignoreTimezone = firstDefined(source.ignoreTimezone, options.ignoreTimezone);
|
|
event._id = event._id || (event.id === undefined ? '_fc' + eventGUID++ : event.id + '');
|
|
if (event.date) {
|
|
if (!event.start) {
|
|
event.start = event.date;
|
|
}
|
|
delete event.date;
|
|
}
|
|
event._start = cloneDate(event.start = parseDate(event.start, ignoreTimezone));
|
|
event.end = parseDate(event.end, ignoreTimezone);
|
|
if (event.end && event.end <= event.start) {
|
|
event.end = null;
|
|
}
|
|
event._end = event.end ? cloneDate(event.end) : null;
|
|
if (event.allDay === undefined) {
|
|
event.allDay = firstDefined(source.allDayDefault, options.allDayDefault);
|
|
}
|
|
if (event.className) {
|
|
if (typeof event.className == 'string') {
|
|
event.className = event.className.split(/\s+/);
|
|
}
|
|
}else{
|
|
event.className = [];
|
|
}
|
|
// TODO: if there is no start date, return false to indicate an invalid event
|
|
}
|
|
|
|
|
|
|
|
/* Utils
|
|
------------------------------------------------------------------------------*/
|
|
|
|
|
|
function normalizeSource(source) {
|
|
if (source.className) {
|
|
// TODO: repeat code, same code for event classNames
|
|
if (typeof source.className == 'string') {
|
|
source.className = source.className.split(/\s+/);
|
|
}
|
|
}else{
|
|
source.className = [];
|
|
}
|
|
var normalizers = fc.sourceNormalizers;
|
|
for (var i=0; i<normalizers.length; i++) {
|
|
normalizers[i](source);
|
|
}
|
|
}
|
|
|
|
|
|
function isSourcesEqual(source1, source2) {
|
|
return source1 && source2 && getSourcePrimitive(source1) == getSourcePrimitive(source2);
|
|
}
|
|
|
|
|
|
function getSourcePrimitive(source) {
|
|
return ((typeof source == 'object') ? (source.events || source.url) : '') || source;
|
|
}
|
|
|
|
|
|
}
|