899 lines
32 KiB
JavaScript
899 lines
32 KiB
JavaScript
// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
|
||
//
|
||
// SPDX-License-Identifier: AGPL-3.0-or-later
|
||
|
||
define([
|
||
'/common/common-util.js',
|
||
], function (Util) {
|
||
var Rec = {};
|
||
|
||
var debug = function () {};
|
||
|
||
// Get week number with any "WKST" (firts day of the week)
|
||
// Week 1 is the first week of the year containing at least 4 days in this year
|
||
// It depends on which day is considered the first day of the week (default Monday)
|
||
// In our case, wkst is a number matching the JS rule: 0 == Sunday
|
||
var getWeekNo = Rec.getWeekNo = function (date, wkst) {
|
||
if (typeof(wkst) !== "number") { wkst = 1; } // Default monday
|
||
|
||
var newYear = new Date(date.getFullYear(),0,1);
|
||
var day = newYear.getDay() - wkst; //the day of week the year begins on
|
||
day = (day >= 0 ? day : day + 7);
|
||
var daynum = Math.floor((date.getTime() - newYear.getTime())/86400000) + 1;
|
||
var weeknum;
|
||
// Week 1 / week 53
|
||
if (day < 4) {
|
||
weeknum = Math.floor((daynum+day-1)/7) + 1;
|
||
if (weeknum > 52) {
|
||
var nYear = new Date(date.getFullYear() + 1,0,1);
|
||
var nday = nYear.getDay() - wkst;
|
||
nday = nday >= 0 ? nday : nday + 7;
|
||
weeknum = nday < 4 ? 1 : 53;
|
||
}
|
||
}
|
||
else {
|
||
weeknum = Math.floor((daynum+day-1)/7);
|
||
}
|
||
return weeknum;
|
||
};
|
||
|
||
var getYearDay = function (date) {
|
||
var start = new Date(date.getFullYear(), 0, 0);
|
||
var diff = (date - start) +
|
||
((start.getTimezoneOffset() - date.getTimezoneOffset()) * 60 * 1000);
|
||
var oneDay = 1000 * 60 * 60 * 24;
|
||
return Math.floor(diff / oneDay);
|
||
};
|
||
var setYearDay = function (date, day) {
|
||
if (typeof(day) !== "number" || Math.abs(day) < 1 || Math.abs(day) > 366) { return; }
|
||
if (day < 0) {
|
||
var max = getYearDay(new Date(date.getFullYear(), 11, 31));
|
||
day = max + day + 1;
|
||
}
|
||
date.setMonth(0);
|
||
date.setDate(day);
|
||
return true;
|
||
};
|
||
|
||
var getEndData = function (s, e) {
|
||
if (s > e) { return void console.error("Wrong data"); }
|
||
var days;
|
||
if (e.getFullYear() === s.getFullYear()) {
|
||
days = getYearDay(e) - getYearDay(s);
|
||
} else { // eYear < sYear
|
||
var tmp = new Date(s.getFullYear(), 11, 31);
|
||
var d1 = getYearDay(tmp) - getYearDay(s); // Number of days before December 31st
|
||
var de = getYearDay(e);
|
||
days = d1 + de;
|
||
while ((tmp.getFullYear()+1) < e.getFullYear()) {
|
||
tmp.setFullYear(tmp.getFullYear()+1);
|
||
days += getYearDay(tmp);
|
||
}
|
||
}
|
||
return {
|
||
h: e.getHours(),
|
||
m: e.getMinutes(),
|
||
days: days
|
||
};
|
||
};
|
||
var setEndData = function (s, e, data) {
|
||
e.setTime(+s);
|
||
if (!data) { return; }
|
||
e.setHours(data.h);
|
||
e.setMinutes(data.m);
|
||
e.setSeconds(0);
|
||
e.setDate(s.getDate() + data.days);
|
||
};
|
||
|
||
var DAYORDER = Rec.DAYORDER = ["SU", "MO", "TU", "WE", "TH", "FR", "SA"];
|
||
var getDayData = function (str) {
|
||
var pos = Number(str.slice(0,-2));
|
||
var day = DAYORDER.indexOf(str.slice(-2));
|
||
return pos ? [pos, day] : day;
|
||
};
|
||
|
||
var goToFirstWeekDay = function (date, wkst) {
|
||
var d = date.getDay();
|
||
wkst = typeof(wkst) === "number" ? wkst : 1;
|
||
if (d >= wkst) {
|
||
date.setDate(date.getDate() - (d-wkst));
|
||
} else {
|
||
date.setDate(date.getDate() - (7+d-wkst));
|
||
}
|
||
};
|
||
|
||
var getDateStr = function (date) {
|
||
return date.getFullYear() + '-' + (date.getMonth()+1) + '-' + date.getDate();
|
||
};
|
||
var FREQ = {};
|
||
FREQ['daily'] = function (s, i) {
|
||
s.setDate(s.getDate()+i);
|
||
};
|
||
FREQ['weekly'] = function (s,i) {
|
||
s.setDate(s.getDate()+(i*7));
|
||
};
|
||
FREQ['monthly'] = function (s,i) {
|
||
s.setMonth(s.getMonth()+i);
|
||
};
|
||
FREQ['yearly'] = function (s,i) {
|
||
s.setFullYear(s.getFullYear()+i);
|
||
};
|
||
|
||
// EXPAND is used to create iterations added from a BYxxx rule
|
||
// dateA is the start date and b is the number or id of the BYxxx rule item
|
||
var EXPAND = {};
|
||
EXPAND['month'] = function (dateS, origin, b) {
|
||
var oS = new Date(origin.start);
|
||
var a = dateS.getMonth() + 1;
|
||
var toAdd = (b-a+12)%12;
|
||
var m = dateS.getMonth() + toAdd;
|
||
dateS.setMonth(m);
|
||
dateS.setDate(oS.getDate());
|
||
if (dateS.getMonth() !== m) { return; } // Day 31 may move us to the next month
|
||
return true;
|
||
};
|
||
|
||
|
||
EXPAND['weekno'] = function (dateS, origin, week, rule) {
|
||
var wkst = rule && rule.wkst;
|
||
if (typeof(wkst) !== "number") { wkst = 1; } // Default monday
|
||
var oS = new Date(origin.start);
|
||
|
||
var lastD = new Date(dateS.getFullYear(), 11, 31); // December 31st
|
||
var lastW = getWeekNo(lastD, wkst); // Last week of the year is either 52 or 53
|
||
|
||
var doubleOne = lastW === 1;
|
||
if (lastW === 1) { lastW = 52; }
|
||
|
||
var a = getWeekNo(dateS, wkst);
|
||
if (!week || week > lastW) { return false; } // Week 53 may not exist this year
|
||
|
||
if (week < 0) { week = lastW + week + 1; } // Turn negative week number into positive
|
||
|
||
var toAdd = week - a;
|
||
var weekS = new Date(+dateS);
|
||
// Go to the selected week
|
||
weekS.setDate(weekS.getDate() + (toAdd * 7));
|
||
goToFirstWeekDay(weekS, wkst);
|
||
|
||
// Then make sure we are in the correct start day
|
||
var all = 'aaaaaaa'.split('').map(function (o, i) {
|
||
var date = new Date(+weekS);
|
||
date.setDate(date.getDate() + i);
|
||
if (date.getFullYear() !== dateS.getFullYear()) { return; }
|
||
return date.toLocaleDateString() !== oS.toLocaleDateString() && date;
|
||
}).filter(Boolean);
|
||
|
||
// If we're looking for week 1 and the last week is a week 1, add the days
|
||
if (week === 1 && doubleOne) {
|
||
goToFirstWeekDay(lastD, wkst);
|
||
'aaaaaaa'.split('').some(function (o, i) {
|
||
var date = new Date(+lastD);
|
||
date.setDate(date.getDate() + i);
|
||
if (date.toLocaleDateString() === oS.toLocaleDateString()) { return; }
|
||
if (date.getFullYear() > dateS.getFullYear()) { return true; }
|
||
all.push(date);
|
||
});
|
||
}
|
||
|
||
return all.length ? all : undefined;
|
||
};
|
||
EXPAND['yearday'] = function (dateS, origin, b) {
|
||
var y = dateS.getFullYear();
|
||
var state = setYearDay(dateS, b);
|
||
if (!state) { return; } // Invalid day "b"
|
||
if (dateS.getFullYear() !== y) { return; } // Day 366 make move us to the next year
|
||
return true;
|
||
};
|
||
EXPAND['monthday'] = function (dateS, origin, b, rule) {
|
||
if (typeof(b) !== "number" || Math.abs(b) < 1 || Math.abs(b) > 31) { return false; }
|
||
|
||
var setMonthDay = function (date, day) {
|
||
var m = date.getMonth();
|
||
if (day < 0) {
|
||
var tmp = new Date(date.getFullYear(), date.getMonth()+1, 0); // Last day
|
||
day = tmp.getDate() + day + 1;
|
||
}
|
||
date.setDate(day);
|
||
return date.getMonth() === m; // Don't push if day 31 moved us to the next month
|
||
|
||
};
|
||
|
||
// Monthly events
|
||
if (rule.freq === 'monthly') {
|
||
return setMonthDay(dateS, b);
|
||
}
|
||
|
||
var all = 'aaaaaaaaaaaa'.split('').map(function (o, i) {
|
||
var date = new Date(dateS.getFullYear(), i, 1);
|
||
var ok = setMonthDay(date, b);
|
||
return ok ? date : undefined;
|
||
}).filter(Boolean);
|
||
return all.length ? all : undefined;
|
||
};
|
||
EXPAND['day'] = function (dateS, origin, b, rule) {
|
||
// Here "b" can be a single day ("TU") or a position and a day ("1MO")
|
||
var day = getDayData(b);
|
||
var pos;
|
||
if (Array.isArray(day)) {
|
||
pos = day[0];
|
||
day = day[1];
|
||
}
|
||
|
||
var all = [];
|
||
if (![0,1,2,3,4,5,6].includes(day)) { return false; }
|
||
|
||
var filterPos = function (m) {
|
||
if (!pos) { return; }
|
||
|
||
var _all = [];
|
||
'aaaaaaaaaaaa'.split('').some(function (a, i) {
|
||
if (typeof(m) !== "undefined" && i !== m) { return; }
|
||
|
||
var _pos;
|
||
var tmp = all.filter(function (d) {
|
||
return d.getMonth() === i;
|
||
});
|
||
if (pos < 0) {
|
||
_pos = tmp.length + pos;
|
||
} else {
|
||
_pos = pos - 1; // An array starts at 0 but the recurrence rule starts at 1
|
||
}
|
||
_all.push(tmp[_pos]);
|
||
|
||
return typeof(m) !== "undefined" && i === m;
|
||
});
|
||
all = _all.filter(Boolean); // The "5th" {day} won't always exist
|
||
};
|
||
|
||
var tmp;
|
||
if (rule.freq === 'yearly') {
|
||
tmp = new Date(+dateS);
|
||
var y = dateS.getFullYear();
|
||
while (tmp.getDay() !== day) { tmp.setDate(tmp.getDate()+1); }
|
||
while (tmp.getFullYear() === y) {
|
||
all.push(new Date(+tmp));
|
||
tmp.setDate(tmp.getDate()+7);
|
||
}
|
||
filterPos();
|
||
return all;
|
||
}
|
||
|
||
if (rule.freq === 'monthly') {
|
||
tmp = new Date(+dateS);
|
||
var m = dateS.getMonth();
|
||
while (tmp.getDay() !== day) { tmp.setDate(tmp.getDate()+1); }
|
||
while (tmp.getMonth() === m) {
|
||
all.push(new Date(+tmp));
|
||
tmp.setDate(tmp.getDate()+7);
|
||
}
|
||
filterPos(m);
|
||
return all;
|
||
}
|
||
|
||
if (rule.freq === 'weekly') {
|
||
while (dateS.getDay() !== day) { dateS.setDate(dateS.getDate()+1); }
|
||
}
|
||
return true;
|
||
};
|
||
|
||
var LIMIT = {};
|
||
LIMIT['month'] = function (events, rule) {
|
||
return events.filter(function (s) {
|
||
return rule.includes(s.getMonth()+1);
|
||
});
|
||
};
|
||
LIMIT['weekno'] = function (events, weeks, rules) {
|
||
return events.filter(function (s) {
|
||
var wkst = rules && rules.wkst;
|
||
if (typeof(wkst) !== "number") { wkst = 1; } // Default monday
|
||
|
||
var lastD = new Date(s.getFullYear(), 11, 31); // December 31st
|
||
var lastW = getWeekNo(lastD, wkst); // Last week of the year is either 52 or 53
|
||
if (lastW === 1) { lastW = 52; }
|
||
|
||
var w = getWeekNo(s, wkst);
|
||
|
||
return weeks.some(function (week) {
|
||
if (week > 0) { return week === w; }
|
||
return w === (lastW + week + 1);
|
||
});
|
||
});
|
||
};
|
||
LIMIT['yearday'] = function (events, days) {
|
||
return events.filter(function (s) {
|
||
var d = getYearDay(s);
|
||
var max = getYearDay(new Date(s.getFullYear(), 11, 31));
|
||
|
||
return days.some(function (day) {
|
||
if (day > 0) { return day === d; }
|
||
return d === (max + day + 1);
|
||
});
|
||
});
|
||
};
|
||
LIMIT['monthday'] = function (events, rule) {
|
||
return events.filter(function (s) {
|
||
var r = Util.clone(rule);
|
||
// Transform the negative monthdays into positive for this specific month
|
||
r = r.map(function (b) {
|
||
if (b < 0) {
|
||
var tmp = new Date(s.getFullYear(), s.getMonth()+1, 0); // Last day
|
||
b = tmp.getDate() + b + 1;
|
||
}
|
||
return b;
|
||
});
|
||
return r.includes(s.getDate());
|
||
});
|
||
};
|
||
LIMIT['day'] = function (events, days, rules) {
|
||
return events.filter(function (s) {
|
||
var dayStr = s.toLocaleDateString();
|
||
|
||
// Check how to handle position in BYDAY rules (last day of the month or the year?)
|
||
var type = 'yearly';
|
||
if (rules.freq === 'monthly' ||
|
||
(rules.freq === 'yearly' && rules.by && rules.by.month)) {
|
||
type = 'monthly';
|
||
}
|
||
|
||
// Check if this event matches one of the allowed days
|
||
return days.some(function (r) {
|
||
// rule elements are strings with pos and day
|
||
var day = getDayData(r);
|
||
var pos;
|
||
if (Array.isArray(day)) {
|
||
pos = day[0];
|
||
day = day[1];
|
||
}
|
||
if (!pos) {
|
||
return s.getDay() === day;
|
||
}
|
||
|
||
// If we have a position, we can use EXPAND.day to get the nth {day} of the
|
||
// year/month and compare if it matches with
|
||
var d = new Date(s.getFullYear(), s.getMonth(), 1);
|
||
if (type === 'yearly') { d.setMonth(0); }
|
||
var res = EXPAND["day"](d, {}, r, {freq: type});
|
||
return res.some(function (date) {
|
||
return date.toLocaleDateString() === dayStr;
|
||
});
|
||
});
|
||
});
|
||
};
|
||
LIMIT['setpos'] = function (events, rule) {
|
||
var init = events.slice();
|
||
var rules = Util.deduplicateString(rule.slice().map(function (n) {
|
||
if (n > 0) { return (n-1); }
|
||
if (n === 0) { return; }
|
||
return init.length + n;
|
||
}));
|
||
return events.filter(function (ev) {
|
||
var idx = init.indexOf(ev);
|
||
return rules.includes(idx);
|
||
});
|
||
};
|
||
|
||
var BYORDER = ['month','weekno','yearday','monthday','day'];
|
||
var BYDAYORDER = ['month','monthday','day'];
|
||
|
||
Rec.getMonthId = function (d) {
|
||
return d.getFullYear() + '-' + d.getMonth();
|
||
};
|
||
var cache = window.CP_calendar_cache = {};
|
||
var recurringAcross = {};
|
||
Rec.resetCache = function () {
|
||
cache = window.CP_calendar_cache = {};
|
||
recurringAcross = {};
|
||
};
|
||
|
||
var iterate = function (rule, _origin, s) {
|
||
// "origin" is the original event to detect the start of BYxxx
|
||
var origin = Util.clone(_origin);
|
||
var oS = new Date(origin.start);
|
||
|
||
var id = origin.id.split('|')[0]; // Use same cache when updating recurrence rule
|
||
|
||
// "uid" is used for the cache
|
||
var uid = s.toLocaleDateString();
|
||
cache[id] = cache[id] || {};
|
||
|
||
var inter = rule.interval || 1;
|
||
var freq = rule.freq;
|
||
|
||
var all = [];
|
||
var limit = function (byrule, n) {
|
||
all = LIMIT[byrule](all, n, rule);
|
||
};
|
||
var expand = function (byrule) {
|
||
return function (n) {
|
||
// Set the start date at the beginning of the current FREQ
|
||
var _s = new Date(+s);
|
||
if (rule.freq === 'yearly') {
|
||
// January 1st
|
||
_s.setMonth(0);
|
||
_s.setDate(1);
|
||
} else if (rule.freq === 'monthly') {
|
||
_s.setDate(1);
|
||
} else if (rule.freq === 'weekly') {
|
||
goToFirstWeekDay(_s, rule.wkst);
|
||
} else if (rule.freq === 'daily') {
|
||
// We don't have < byday rules so we can't expand daily rules
|
||
}
|
||
|
||
var add = EXPAND[byrule](_s, origin, n, rule);
|
||
|
||
if (!add) { return; }
|
||
|
||
if (Array.isArray(add)) {
|
||
add = add.filter(function (dateS) {
|
||
return dateS.toLocaleDateString() !== oS.toLocaleDateString();
|
||
});
|
||
Array.prototype.push.apply(all, add);
|
||
} else {
|
||
if (_s.toLocaleDateString() === oS.toLocaleDateString()) { return; }
|
||
all.push(_s);
|
||
}
|
||
};
|
||
};
|
||
|
||
// Manage interval for the next iteration
|
||
var it = Util.once(function () {
|
||
FREQ[freq](s, inter);
|
||
});
|
||
var addDefault = function () {
|
||
if (freq === "monthly") {
|
||
s.setDate(15);
|
||
} else if (freq === "yearly" && oS.getMonth() === 1 && oS.getDate() === 29) {
|
||
s.setDate(28);
|
||
}
|
||
|
||
it();
|
||
|
||
var _s = new Date(+s);
|
||
if (freq === "monthly" || freq === "yearly") {
|
||
_s.setDate(oS.getDate());
|
||
if (_s.getDate() !== oS.getDate()) { return; } // If 31st or Feb 29th doesn't exist
|
||
if (freq === "yearly" && _s.getMonth() !== oS.getMonth()) { return; }
|
||
|
||
// FIXME if there is a recUpdate that moves the 31st to the 30th, the event
|
||
// will still only be displayed on months with 31 days
|
||
}
|
||
all.push(_s);
|
||
};
|
||
|
||
if (Array.isArray(cache[id][uid])) {
|
||
debug('Get cache', id, uid);
|
||
if (freq === "monthly") {
|
||
s.setDate(15);
|
||
} else if (freq === "yearly" && oS.getMonth() === 1 && oS.getDate() === 29) {
|
||
s.setDate(28);
|
||
}
|
||
it();
|
||
return cache[id][uid];
|
||
}
|
||
|
||
if (rule.by && freq === 'yearly') {
|
||
var order = BYORDER.slice();
|
||
var monthLimit = false;
|
||
if (rule.by.weekno || rule.by.yearday || rule.by.monthday || rule.by.day) {
|
||
order.shift();
|
||
monthLimit = true;
|
||
}
|
||
var first = true;
|
||
order.forEach(function (_order) {
|
||
var r = rule.by[_order];
|
||
if (!r) { return; }
|
||
if (first) {
|
||
r.forEach(expand(_order));
|
||
first = false;
|
||
} else if (_order === "day") {
|
||
if (rule.by.yearday || rule.by.monthday || rule.by.weekno) {
|
||
limit('day', rule.by.day);
|
||
} else {
|
||
rule.by.day.forEach(expand('day'));
|
||
}
|
||
} else {
|
||
limit(_order, r);
|
||
}
|
||
});
|
||
if (rule.by.month && monthLimit) {
|
||
limit('month', rule.by.month);
|
||
}
|
||
}
|
||
if (rule.by && freq === 'monthly') {
|
||
// We're going to compute all the entries for the coming month
|
||
if (!rule.by.monthday && !rule.by.day) {
|
||
addDefault();
|
||
} else if (rule.by.monthday) {
|
||
rule.by.monthday.forEach(expand('monthday'));
|
||
} else if (rule.by.day) {
|
||
rule.by.day.forEach(expand('day'));
|
||
}
|
||
if (rule.by.month) {
|
||
limit('month', rule.by.month);
|
||
}
|
||
if (rule.by.day && rule.by.monthday) {
|
||
limit('day', rule.by.day);
|
||
}
|
||
}
|
||
if (rule.by && freq === 'weekly') {
|
||
// We're going to compute all the entries for the coming week
|
||
if (!rule.by.day) {
|
||
addDefault();
|
||
} else {
|
||
rule.by.day.forEach(expand('day'));
|
||
}
|
||
if (rule.by.month) {
|
||
limit('month', rule.by.month);
|
||
}
|
||
}
|
||
if (rule.by && freq === 'daily') {
|
||
addDefault();
|
||
BYDAYORDER.forEach(function (_order) {
|
||
var r = rule.by[_order];
|
||
if (!r) { return; }
|
||
limit(_order, r);
|
||
});
|
||
}
|
||
|
||
all.sort(function (a, b) {
|
||
return a-b;
|
||
});
|
||
|
||
if (rule.by && rule.by.setpos) {
|
||
limit('setpos', rule.by.setpos);
|
||
}
|
||
|
||
if (!rule.by || !Object.keys(rule.by).length) {
|
||
addDefault();
|
||
} else {
|
||
it();
|
||
}
|
||
|
||
|
||
var done = [];
|
||
all = all.filter(function (newS) {
|
||
var start = new Date(+newS).toLocaleDateString();
|
||
if (done.includes(start)) { return false; }
|
||
done.push(start);
|
||
return true;
|
||
});
|
||
|
||
debug('Set cache', id, uid);
|
||
cache[id][uid] = all;
|
||
|
||
return all;
|
||
};
|
||
|
||
var getNextRules = function (obj) {
|
||
if (!obj.recUpdate) { return []; }
|
||
var _allRules = {};
|
||
var _obj = obj.recUpdate.from;
|
||
Object.keys(_obj || {}).forEach(function (d) {
|
||
var u = _obj[d];
|
||
if (u.recurrenceRule) { _allRules[d] = u.recurrenceRule; }
|
||
});
|
||
return Object.keys(_allRules).sort(function (a, b) { return Number(a)-Number(b); })
|
||
.map(function (k) {
|
||
var r = Util.clone(_allRules[k]);
|
||
if (!FREQ[r.freq]) { return; }
|
||
if (r.interval && r.interval < 1) { return; }
|
||
r._start = Number(k);
|
||
return r;
|
||
}).filter(Boolean);
|
||
};
|
||
|
||
var fixTimeZone = function (evTimeZone, origin, target) {
|
||
var getOffset = function (date, tz) {
|
||
// Get an ISO string using Canadian local format
|
||
let iso = date.toLocaleString('en-CA', { timeZone:tz, hour12: false }).replace(', ', 'T');
|
||
iso += '.' + date.getMilliseconds().toString().padStart(3, '0');
|
||
|
||
// Get a UTC version of this time
|
||
let utcDate = new Date(iso + 'Z');
|
||
|
||
// Return the difference in timestamps, as minutes (60*1000)
|
||
return -(utcDate - date);
|
||
};
|
||
|
||
var myTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
|
||
var offset = getOffset(origin, evTimeZone) - getOffset(target, evTimeZone);
|
||
var myOffset = getOffset(origin, myTimeZone) - getOffset(target, myTimeZone);
|
||
|
||
return myOffset - offset;
|
||
};
|
||
|
||
Rec.getRecurring = function (months, events) {
|
||
if (window.CP_DEV_MODE) { debug = console.warn; }
|
||
|
||
var toAdd = [];
|
||
months.forEach(function (monthId) {
|
||
// from 1st day of the month at 00:00 to last day at 23:59:59:999
|
||
var ms = monthId.split('-');
|
||
var _startMonth = new Date(ms[0], ms[1]);
|
||
var _endMonth = new Date(+_startMonth);
|
||
_endMonth.setMonth(_endMonth.getMonth() + 1);
|
||
_endMonth.setMilliseconds(-1);
|
||
|
||
debug('Compute month', _startMonth.toLocaleDateString());
|
||
|
||
var rec = events || [];
|
||
rec.forEach(function (obj) {
|
||
var _start = new Date(obj.start);
|
||
var _end = new Date(obj.end);
|
||
var _origin = obj;
|
||
var rule = obj.recurrenceRule;
|
||
if (!rule) { return; }
|
||
|
||
var nextRules = getNextRules(obj);
|
||
var nextRule = nextRules.shift();
|
||
|
||
if (_start >= _endMonth) { return; }
|
||
|
||
// Check the "until" date of the latest rule we can use and stop now
|
||
// if the recurrence ends before the current month
|
||
var until = rule.until;
|
||
var _nextRules = nextRules.slice();
|
||
var _nextRule = nextRule;
|
||
while (_nextRule && _nextRule._start && _nextRule._start < _startMonth) {
|
||
until = nextRule.until;
|
||
_nextRule = _nextRules.shift();
|
||
}
|
||
if (until < _startMonth) { return; }
|
||
|
||
var endData = getEndData(_start, _end);
|
||
|
||
if (rule.interval && rule.interval < 1) { return; }
|
||
if (!FREQ[rule.freq]) { return; }
|
||
|
||
/*
|
||
// Rule examples
|
||
rule.by = {
|
||
//month: [1, 4, 5, 8, 12],
|
||
//weekno: [1, 2, 4, 5, 32, 34, 35, 50],
|
||
//yearday: [1, 2, 29, 30, -2, -1, 250],
|
||
//monthday: [1, 2, 3, -3, -2, -1],
|
||
//day: ["MO", "WE", "FR"],
|
||
//setpos: [1, 2, -1, -2]
|
||
};
|
||
rule.wkst = 0;
|
||
rule.interval = 2;
|
||
rule.freq = 'yearly';
|
||
rule.count = 10;
|
||
*/
|
||
debug('Iterate over', obj.title, obj);
|
||
debug('Use rule', rule);
|
||
|
||
var count = rule.count;
|
||
var c = 1;
|
||
|
||
var next = function (start) {
|
||
var evS = new Date(+start);
|
||
|
||
if (count && c >= count) { return; }
|
||
|
||
debug('Start iteration', evS.toLocaleDateString());
|
||
|
||
var _toAdd = iterate(rule, obj, evS);
|
||
|
||
debug('Iteration results', JSON.stringify(_toAdd.map(function (o) { return new Date(o).toLocaleDateString();})));
|
||
|
||
// Make sure to continue if the current year doesn't provide any result
|
||
if (!_toAdd.length) {
|
||
if (evS.getFullYear() < _startMonth.getFullYear() ||
|
||
evS < _endMonth) {
|
||
return void next(evS);
|
||
}
|
||
return;
|
||
}
|
||
|
||
|
||
var stop = false;
|
||
var newrule = false;
|
||
_toAdd.some(function (_newS) {
|
||
// Make event with correct start and end time
|
||
var _ev = Util.clone(obj);
|
||
_ev.id = _origin.id + '|' + (+_newS);
|
||
var _evS = new Date(+_newS);
|
||
var _evE = new Date(+_newS);
|
||
setEndData(_evS, _evE, endData);
|
||
_ev.start = +_evS;
|
||
_ev.end = +_evE;
|
||
_ev._count = c;
|
||
if (_ev.isAllDay && _ev.startDay) { _ev.startDay = getDateStr(_evS); }
|
||
if (_ev.isAllDay && _ev.endDay) { _ev.endDay = getDateStr(_evE); }
|
||
|
||
if (nextRule && _ev.start === nextRule._start) {
|
||
newrule = true;
|
||
}
|
||
|
||
var useNewRule = function () {
|
||
if (!newrule) { return; }
|
||
debug('Use new rule', nextRule);
|
||
_ev._count = c;
|
||
count = nextRule.count;
|
||
c = 1;
|
||
evS = +_evS;
|
||
obj = _ev;
|
||
rule = nextRule;
|
||
nextRule = nextRules.shift();
|
||
};
|
||
|
||
|
||
if (c >= count) { // Limit reached
|
||
debug(_evS.toLocaleDateString(), 'count');
|
||
stop = true;
|
||
return true;
|
||
}
|
||
if (_evS >= _endMonth) { // Won't affect us anymore
|
||
debug(_evS.toLocaleDateString(), 'endMonth');
|
||
stop = true;
|
||
return true;
|
||
}
|
||
if (rule.until && _evS > rule.until) {
|
||
debug(_evS.toLocaleDateString(), 'until');
|
||
stop = true;
|
||
return true;
|
||
}
|
||
if (_evS < _start) { // "Expand" rules may create events before the _start
|
||
debug(_evS.toLocaleDateString(), 'start');
|
||
return;
|
||
}
|
||
c++;
|
||
if (_evE < _startMonth) { // Ended before the current month
|
||
// Nothing to display but continue the recurrence
|
||
debug(_evS.toLocaleDateString(), 'startMonth');
|
||
if (newrule) { useNewRule(); }
|
||
return;
|
||
}
|
||
// If a recurring event start and end in different months, make sure
|
||
// it is only added once
|
||
if ((_evS < _endMonth && _evE >= _endMonth) ||
|
||
(_evS < _startMonth && _evE >= _startMonth)) {
|
||
if (recurringAcross[_ev.id] && recurringAcross[_ev.id].includes(_ev.start)) {
|
||
return;
|
||
} else {
|
||
recurringAcross[_ev.id] = recurringAcross[_ev.id] || [];
|
||
recurringAcross[_ev.id].push(_ev.start);
|
||
}
|
||
|
||
}
|
||
|
||
// Add this event
|
||
if (_origin.timeZone && !_ev.isAllDay) {
|
||
var offset = fixTimeZone(_origin.timeZone, _start, _evS);
|
||
_ev.start += offset;
|
||
_ev.end += offset;
|
||
}
|
||
toAdd.push(_ev);
|
||
if (newrule) {
|
||
useNewRule();
|
||
return true;
|
||
}
|
||
});
|
||
if (!stop) { next(evS); }
|
||
};
|
||
next(_start);
|
||
debug('Added this month (all events)', toAdd.map(function (ev) {
|
||
return new Date(ev.start).toLocaleDateString();
|
||
}));
|
||
});
|
||
});
|
||
return toAdd;
|
||
};
|
||
Rec.getAllOccurrences = function (ev) {
|
||
if (!ev.recurrenceRule) { return [ev.start]; }
|
||
var r = ev.recurrenceRule;
|
||
// In case of infinite recursion, we can't get all
|
||
if (!r.until && !r.count) { return false; }
|
||
var all = [ev.start];
|
||
var d = new Date(ev.start);
|
||
d.setDate(15); // Make sure we won't skip a month if the event starts on day > 28
|
||
var toAdd = [];
|
||
|
||
var i = 0;
|
||
var check = function () {
|
||
return r.count ? (all.length < r.count) : (+d <= r.until);
|
||
};
|
||
while ((toAdd = Rec.getRecurring([Rec.getMonthId(d)], [ev])) && check() && i < (r.count*12)) {
|
||
Array.prototype.push.apply(all, toAdd.map(function (_ev) { return _ev.start; }));
|
||
d.setMonth(d.getMonth() + 1);
|
||
i++;
|
||
}
|
||
|
||
return all;
|
||
};
|
||
|
||
Rec.diffDate = function (oldTime, newTime) {
|
||
var n = new Date(newTime);
|
||
var o = new Date(oldTime);
|
||
|
||
// Diff Days
|
||
var d = 0;
|
||
var mult = n < o ? -1 : 1;
|
||
while (n.toLocaleDateString() !== o.toLocaleDateString() || mult >= 10000) {
|
||
n.setDate(n.getDate() - mult);
|
||
d++;
|
||
}
|
||
d = mult * d;
|
||
|
||
// Diff hours
|
||
n = new Date(newTime);
|
||
var h = n.getHours() - o.getHours();
|
||
|
||
// Diff minutes
|
||
var m = n.getMinutes() - o.getMinutes();
|
||
|
||
return {
|
||
d: d,
|
||
h: h,
|
||
m: m
|
||
};
|
||
};
|
||
|
||
var sortUpdate = function (obj) {
|
||
return Object.keys(obj).sort(function (d1, d2) {
|
||
return Number(d1) - Number(d2);
|
||
});
|
||
};
|
||
Rec.applyUpdates = function (events) {
|
||
events.forEach(function (ev) {
|
||
ev.raw = {
|
||
start: ev.start,
|
||
end: ev.end,
|
||
};
|
||
|
||
if (!ev.recUpdate) { return; }
|
||
|
||
var from = ev.recUpdate.from || {};
|
||
var one = ev.recUpdate.one || {};
|
||
var s = ev.start;
|
||
|
||
// Add "until" date to our recurrenceRule if it has been modified in future occurences
|
||
var nextRules = getNextRules(ev).filter(function (r) {
|
||
return r._start > s;
|
||
});
|
||
var nextRule = nextRules.shift();
|
||
|
||
var applyDiff = function (obj, k) {
|
||
var diff = obj[k]; // Diff is always compared to origin start/end
|
||
var d = new Date(ev.raw[k]);
|
||
d.setDate(d.getDate() + diff.d);
|
||
d.setHours(d.getHours() + diff.h);
|
||
d.setMinutes(d.getMinutes() + diff.m);
|
||
ev[k] = +d;
|
||
};
|
||
|
||
sortUpdate(from).forEach(function (d) {
|
||
if (s < Number(d)) { return; }
|
||
Object.keys(from[d]).forEach(function (k) {
|
||
if (k === 'start' || k === 'end') { return void applyDiff(from[d], k); }
|
||
if (k === "recurrenceRule" && !from[d][k]) { return; }
|
||
ev[k] = from[d][k];
|
||
});
|
||
});
|
||
Object.keys(one[s] || {}).forEach(function (k) {
|
||
if (k === 'start' || k === 'end') { return void applyDiff(one[s], k); }
|
||
if (k === "recurrenceRule" && !one[s][k]) { return; }
|
||
ev[k] = one[s][k];
|
||
});
|
||
if (ev.deleted) {
|
||
Object.keys(ev).forEach(function (k) {
|
||
delete ev[k];
|
||
});
|
||
}
|
||
|
||
if (nextRule && ev.recurrenceRule) {
|
||
ev.recurrenceRule._next = nextRule._start - 1;
|
||
}
|
||
|
||
if (ev.reminders) {
|
||
ev.raw.reminders = ev.reminders;
|
||
}
|
||
});
|
||
return events;
|
||
};
|
||
|
||
|
||
return Rec;
|
||
});
|