mirror of
https://github.com/MichMich/MagicMirror.git
synced 2025-06-27 11:50:00 +00:00
382 lines
9.6 KiB
JavaScript
382 lines
9.6 KiB
JavaScript
/* Magic Mirror
|
|
* Node Helper: Calendar - CalendarFetcher
|
|
*
|
|
* By Michael Teeuw http://michaelteeuw.nl
|
|
* MIT Licensed.
|
|
*/
|
|
|
|
var ical = require("./vendor/ical.js");
|
|
var moment = require("moment");
|
|
|
|
var CalendarFetcher = function(url, reloadInterval, excludedEvents, maximumEntries, maximumNumberOfDays, auth) {
|
|
var self = this;
|
|
|
|
var reloadTimer = null;
|
|
var events = [];
|
|
|
|
var fetchFailedCallback = function() {};
|
|
var eventsReceivedCallback = function() {};
|
|
|
|
/* fetchCalendar()
|
|
* Initiates calendar fetch.
|
|
*/
|
|
var fetchCalendar = function() {
|
|
|
|
clearTimeout(reloadTimer);
|
|
reloadTimer = null;
|
|
|
|
nodeVersion = Number(process.version.match(/^v(\d+\.\d+)/)[1]);
|
|
var opts = {
|
|
headers: {
|
|
"User-Agent": "Mozilla/5.0 (Node.js "+ nodeVersion + ") MagicMirror/" + global.version + " (https://github.com/MichMich/MagicMirror/)"
|
|
}
|
|
};
|
|
|
|
if (auth) {
|
|
if(auth.method === "bearer"){
|
|
opts.auth = {
|
|
bearer: auth.pass
|
|
}
|
|
|
|
}else{
|
|
opts.auth = {
|
|
user: auth.user,
|
|
pass: auth.pass
|
|
};
|
|
|
|
if(auth.method === "digest"){
|
|
opts.auth.sendImmediately = false;
|
|
}else{
|
|
opts.auth.sendImmediately = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
ical.fromURL(url, opts, function(err, data) {
|
|
if (err) {
|
|
fetchFailedCallback(self, err);
|
|
scheduleTimer();
|
|
return;
|
|
}
|
|
|
|
// console.log(data);
|
|
newEvents = [];
|
|
|
|
var limitFunction = function(date, i) {return i < maximumEntries;};
|
|
|
|
var eventDate = function(event, time) {
|
|
return (event[time].length === 8) ? moment(event[time], "YYYYMMDD") : moment(new Date(event[time]));
|
|
};
|
|
|
|
for (var e in data) {
|
|
var event = data[e];
|
|
var now = new Date();
|
|
var today = moment().startOf("day").toDate();
|
|
var future = moment().startOf("day").add(maximumNumberOfDays, "days").subtract(1,"seconds").toDate(); // Subtract 1 second so that events that start on the middle of the night will not repeat.
|
|
|
|
// FIXME:
|
|
// Ugly fix to solve the facebook birthday issue.
|
|
// Otherwise, the recurring events only show the birthday for next year.
|
|
var isFacebookBirthday = false;
|
|
if (typeof event.uid !== "undefined") {
|
|
if (event.uid.indexOf("@facebook.com") !== -1) {
|
|
isFacebookBirthday = true;
|
|
}
|
|
}
|
|
|
|
if (event.type === "VEVENT") {
|
|
|
|
var startDate = eventDate(event, "start");
|
|
var endDate;
|
|
if (typeof event.end !== "undefined") {
|
|
endDate = eventDate(event, "end");
|
|
} else if(typeof event.duration !== "undefined") {
|
|
dur=moment.duration(event.duration);
|
|
endDate = startDate.clone().add(dur);
|
|
} else {
|
|
if (!isFacebookBirthday) {
|
|
endDate = startDate;
|
|
} else {
|
|
endDate = moment(startDate).add(1, "days");
|
|
}
|
|
}
|
|
|
|
|
|
// calculate the duration f the event for use with recurring events.
|
|
var duration = parseInt(endDate.format("x")) - parseInt(startDate.format("x"));
|
|
|
|
if (event.start.length === 8) {
|
|
startDate = startDate.startOf("day");
|
|
}
|
|
|
|
var title = "Event";
|
|
if (event.summary) {
|
|
title = (typeof event.summary.val !== "undefined") ? event.summary.val : event.summary;
|
|
} else if(event.description) {
|
|
title = event.description;
|
|
}
|
|
|
|
var excluded = false,
|
|
dateFilter = null;
|
|
|
|
for (var f in excludedEvents) {
|
|
var filter = excludedEvents[f],
|
|
testTitle = title.toLowerCase(),
|
|
until = null,
|
|
useRegex = false,
|
|
regexFlags = "g";
|
|
|
|
if (filter instanceof Object) {
|
|
if (typeof filter.until !== "undefined") {
|
|
until = filter.until;
|
|
}
|
|
|
|
if (typeof filter.regex !== "undefined") {
|
|
useRegex = filter.regex;
|
|
}
|
|
|
|
// If additional advanced filtering is added in, this section
|
|
// must remain last as we overwrite the filter object with the
|
|
// filterBy string
|
|
if (filter.caseSensitive) {
|
|
filter = filter.filterBy;
|
|
testTitle = title;
|
|
} else if (useRegex) {
|
|
filter = filter.filterBy;
|
|
testTitle = title;
|
|
regexFlags += "i";
|
|
} else {
|
|
filter = filter.filterBy.toLowerCase();
|
|
}
|
|
} else {
|
|
filter = filter.toLowerCase();
|
|
}
|
|
|
|
if (testTitleByFilter(testTitle, filter, useRegex, regexFlags)) {
|
|
if (until) {
|
|
dateFilter = until;
|
|
} else {
|
|
excluded = true;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (excluded) {
|
|
continue;
|
|
}
|
|
|
|
var location = event.location || false;
|
|
var geo = event.geo || false;
|
|
var description = event.description || false;
|
|
|
|
if (typeof event.rrule != "undefined" && !isFacebookBirthday) {
|
|
var rule = event.rrule;
|
|
var dates = rule.between(today, future, true, limitFunction);
|
|
|
|
for (var d in dates) {
|
|
startDate = moment(new Date(dates[d]));
|
|
endDate = moment(parseInt(startDate.format("x")) + duration, "x");
|
|
|
|
if (timeFilterApplies(now, endDate, dateFilter)) {
|
|
continue;
|
|
}
|
|
|
|
if (endDate.format("x") > now) {
|
|
newEvents.push({
|
|
title: title,
|
|
startDate: startDate.format("x"),
|
|
endDate: endDate.format("x"),
|
|
fullDayEvent: isFullDayEvent(event),
|
|
class: event.class,
|
|
firstYear: event.start.getFullYear(),
|
|
location: location,
|
|
geo: geo,
|
|
description: description
|
|
});
|
|
}
|
|
}
|
|
} else {
|
|
// console.log("Single event ...");
|
|
// Single event.
|
|
var fullDayEvent = (isFacebookBirthday) ? true : isFullDayEvent(event);
|
|
|
|
if (!fullDayEvent && endDate < new Date()) {
|
|
//console.log("It's not a fullday event, and it is in the past. So skip: " + title);
|
|
continue;
|
|
}
|
|
|
|
if (fullDayEvent && endDate <= today) {
|
|
//console.log("It's a fullday event, and it is before today. So skip: " + title);
|
|
continue;
|
|
}
|
|
|
|
if (startDate > future) {
|
|
//console.log("It exceeds the maximumNumberOfDays limit. So skip: " + title);
|
|
continue;
|
|
}
|
|
|
|
if (timeFilterApplies(now, endDate, dateFilter)) {
|
|
continue;
|
|
}
|
|
|
|
// Every thing is good. Add it to the list.
|
|
|
|
newEvents.push({
|
|
title: title,
|
|
startDate: startDate.format("x"),
|
|
endDate: endDate.format("x"),
|
|
fullDayEvent: fullDayEvent,
|
|
class: event.class,
|
|
location: location,
|
|
geo: geo,
|
|
description: description
|
|
});
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
newEvents.sort(function(a, b) {
|
|
return a.startDate - b.startDate;
|
|
});
|
|
|
|
//console.log(newEvents);
|
|
|
|
events = newEvents.slice(0, maximumEntries);
|
|
|
|
self.broadcastEvents();
|
|
scheduleTimer();
|
|
});
|
|
};
|
|
|
|
/* scheduleTimer()
|
|
* Schedule the timer for the next update.
|
|
*/
|
|
var scheduleTimer = function() {
|
|
//console.log('Schedule update timer.');
|
|
clearTimeout(reloadTimer);
|
|
reloadTimer = setTimeout(function() {
|
|
fetchCalendar();
|
|
}, reloadInterval);
|
|
};
|
|
|
|
/* isFullDayEvent(event)
|
|
* Checks if an event is a fullday event.
|
|
*
|
|
* argument event obejct - The event object to check.
|
|
*
|
|
* return bool - The event is a fullday event.
|
|
*/
|
|
var isFullDayEvent = function(event) {
|
|
if (event.start.length === 8) {
|
|
return true;
|
|
}
|
|
|
|
var start = event.start || 0;
|
|
var startDate = new Date(start);
|
|
var end = event.end || 0;
|
|
if (((end - start) % (24 * 60 * 60 * 1000)) === 0 && startDate.getHours() === 0 && startDate.getMinutes() === 0) {
|
|
// Is 24 hours, and starts on the middle of the night.
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
/* timeFilterApplies()
|
|
* Determines if the user defined time filter should apply
|
|
*
|
|
* argument now Date - Date object using previously created object for consistency
|
|
* argument endDate Moment - Moment object representing the event end date
|
|
* argument filter string - The time to subtract from the end date to determine if an event should be shown
|
|
*
|
|
* return bool - The event should be filtered out
|
|
*/
|
|
var timeFilterApplies = function(now, endDate, filter) {
|
|
if (filter) {
|
|
var until = filter.split(" "),
|
|
value = parseInt(until[0]),
|
|
increment = until[1].slice("-1") === "s" ? until[1] : until[1] + "s", // Massage the data for moment js
|
|
filterUntil = moment(endDate.format()).subtract(value, increment);
|
|
|
|
return now < filterUntil.format("x");
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
var testTitleByFilter = function (title, filter, useRegex, regexFlags) {
|
|
if (useRegex) {
|
|
// Assume if leading slash, there is also trailing slash
|
|
if (filter[0] === "/") {
|
|
// Strip leading and trailing slashes
|
|
filter = filter.substr(1).slice(0, -1);
|
|
}
|
|
|
|
filter = new RegExp(filter, regexFlags);
|
|
|
|
return filter.test(title);
|
|
} else {
|
|
return title.includes(filter);
|
|
}
|
|
}
|
|
|
|
/* public methods */
|
|
|
|
/* startFetch()
|
|
* Initiate fetchCalendar();
|
|
*/
|
|
this.startFetch = function() {
|
|
fetchCalendar();
|
|
};
|
|
|
|
/* broadcastItems()
|
|
* Broadcast the existing events.
|
|
*/
|
|
this.broadcastEvents = function() {
|
|
//console.log('Broadcasting ' + events.length + ' events.');
|
|
eventsReceivedCallback(self);
|
|
};
|
|
|
|
/* onReceive(callback)
|
|
* Sets the on success callback
|
|
*
|
|
* argument callback function - The on success callback.
|
|
*/
|
|
this.onReceive = function(callback) {
|
|
eventsReceivedCallback = callback;
|
|
};
|
|
|
|
/* onError(callback)
|
|
* Sets the on error callback
|
|
*
|
|
* argument callback function - The on error callback.
|
|
*/
|
|
this.onError = function(callback) {
|
|
fetchFailedCallback = callback;
|
|
};
|
|
|
|
/* url()
|
|
* Returns the url of this fetcher.
|
|
*
|
|
* return string - The url of this fetcher.
|
|
*/
|
|
this.url = function() {
|
|
return url;
|
|
};
|
|
|
|
/* events()
|
|
* Returns current available events for this fetcher.
|
|
*
|
|
* return array - The current available events for this fetcher.
|
|
*/
|
|
this.events = function() {
|
|
return events;
|
|
};
|
|
|
|
};
|
|
|
|
|
|
module.exports = CalendarFetcher;
|