jiti-meet/react/features/calendar-sync/middleware.js

326 lines
10 KiB
JavaScript
Raw Normal View History

2018-02-08 18:50:19 +00:00
// @flow
2018-04-16 02:04:57 +00:00
2018-06-11 12:25:24 +00:00
import md5 from 'js-md5';
2018-02-08 18:50:19 +00:00
import RNCalendarEvents from 'react-native-calendar-events';
import { APP_WILL_MOUNT } from '../base/app';
import { ADD_KNOWN_DOMAINS, addKnownDomains } from '../base/known-domains';
2018-02-08 18:50:19 +00:00
import { MiddlewareRegistry } from '../base/redux';
2018-02-14 20:34:33 +00:00
import { APP_LINK_SCHEME, parseURIString } from '../base/util';
import { APP_STATE_CHANGED } from '../mobile/background';
2018-02-08 18:50:19 +00:00
2018-05-14 15:55:40 +00:00
import { setCalendarAuthorization, setCalendarEvents } from './actions';
2018-04-16 02:04:57 +00:00
import { REFRESH_CALENDAR } from './actionTypes';
2018-04-16 16:39:26 +00:00
import { CALENDAR_ENABLED } from './constants';
2018-04-16 02:04:57 +00:00
const logger = require('jitsi-meet-logger').getLogger(__filename);
2018-02-08 18:50:19 +00:00
/**
2018-05-14 15:55:40 +00:00
* The number of days to fetch.
*/
2018-02-08 18:50:19 +00:00
const FETCH_END_DAYS = 10;
/**
2018-05-14 15:55:40 +00:00
* The number of days to go back when fetching.
*/
2018-02-08 18:50:19 +00:00
const FETCH_START_DAYS = -1;
/**
* The max number of events to fetch from the calendar.
*/
2018-02-08 18:50:19 +00:00
const MAX_LIST_LENGTH = 10;
2018-04-16 16:39:26 +00:00
CALENDAR_ENABLED
&& MiddlewareRegistry.register(store => next => action => {
switch (action.type) {
case ADD_KNOWN_DOMAINS: {
// XXX Fetch new calendar entries only when an actual domain has
// become known.
const { getState } = store;
const oldValue = getState()['features/base/known-domains'];
const result = next(action);
const newValue = getState()['features/base/known-domains'];
oldValue === newValue || _fetchCalendarEntries(store, false, false);
return result;
}
case APP_STATE_CHANGED: {
const result = next(action);
2018-04-16 02:04:57 +00:00
2018-05-14 15:55:40 +00:00
_maybeClearAccessStatus(store, action);
return result;
}
case APP_WILL_MOUNT: {
// For legacy purposes, we've allowed the deserialization of
// knownDomains and now we're to translate it to base/known-domains.
const state = store.getState()['features/calendar-sync'];
if (state) {
const { knownDomains } = state;
Array.isArray(knownDomains)
&& knownDomains.length
&& store.dispatch(addKnownDomains(knownDomains));
}
_fetchCalendarEntries(store, false, false);
return next(action);
}
case REFRESH_CALENDAR: {
const result = next(action);
_fetchCalendarEntries(
store, action.isInteractive, action.forcePermission);
return result;
}
2018-04-16 16:39:26 +00:00
}
2018-02-08 18:50:19 +00:00
return next(action);
2018-04-16 16:39:26 +00:00
});
2018-02-08 18:50:19 +00:00
/**
* Ensures calendar access if possible and resolves the promise if it's granted.
*
* @param {boolean} promptForPermission - Flag to tell the app if it should
* prompt for a calendar permission if it wasn't granted yet.
* @param {Function} dispatch - The Redux dispatch function.
2018-04-16 02:04:57 +00:00
* @private
2018-02-08 18:50:19 +00:00
* @returns {Promise}
*/
function _ensureCalendarAccess(promptForPermission, dispatch) {
2018-02-08 18:50:19 +00:00
return new Promise((resolve, reject) => {
RNCalendarEvents.authorizationStatus()
.then(status => {
if (status === 'authorized') {
resolve(true);
} else if (promptForPermission) {
2018-02-08 18:50:19 +00:00
RNCalendarEvents.authorizeEventStore()
.then(result => {
2018-04-16 02:04:57 +00:00
dispatch(setCalendarAuthorization(result));
resolve(result === 'authorized');
2018-02-08 18:50:19 +00:00
})
2018-04-16 02:04:57 +00:00
.catch(reject);
2018-02-08 18:50:19 +00:00
} else {
resolve(false);
2018-02-08 18:50:19 +00:00
}
})
2018-04-16 02:04:57 +00:00
.catch(reject);
2018-02-08 18:50:19 +00:00
});
}
/**
* Reads the user's calendar and updates the stored entries if need be.
*
* @param {Object} store - The redux store.
* @param {boolean} maybePromptForPermission - Flag to tell the app if it should
* prompt for a calendar permission if it wasn't granted yet.
2018-04-16 02:04:57 +00:00
* @param {boolean|undefined} forcePermission - Whether to force to re-ask for
* the permission or not.
* @private
2018-02-08 18:50:19 +00:00
* @returns {void}
*/
function _fetchCalendarEntries(
2018-05-14 15:55:40 +00:00
store,
maybePromptForPermission,
2018-04-16 02:04:57 +00:00
forcePermission) {
2018-05-14 15:55:40 +00:00
const { dispatch, getState } = store;
const promptForPermission
2018-05-14 15:55:40 +00:00
= (maybePromptForPermission
&& !getState()['features/calendar-sync'].authorization)
2018-04-16 02:04:57 +00:00
|| forcePermission;
_ensureCalendarAccess(promptForPermission, dispatch)
2018-04-16 02:04:57 +00:00
.then(accessGranted => {
if (accessGranted) {
const startDate = new Date();
const endDate = new Date();
startDate.setDate(startDate.getDate() + FETCH_START_DAYS);
endDate.setDate(endDate.getDate() + FETCH_END_DAYS);
RNCalendarEvents.fetchAllEvents(
startDate.getTime(),
endDate.getTime(),
[])
2018-05-14 15:55:40 +00:00
.then(_updateCalendarEntries.bind(store))
2018-04-16 02:04:57 +00:00
.catch(error =>
logger.error('Error fetching calendar.', error));
} else {
logger.warn('Calendar access not granted.');
}
})
.catch(reason => logger.error('Error accessing calendar.', reason));
2018-02-08 18:50:19 +00:00
}
/**
2018-04-16 23:07:25 +00:00
* Retrieves a Jitsi Meet URL from an event if present.
2018-02-08 18:50:19 +00:00
*
* @param {Object} event - The event to parse.
2018-02-14 16:21:52 +00:00
* @param {Array<string>} knownDomains - The known domain names.
2018-04-16 02:04:57 +00:00
* @private
2018-02-08 18:50:19 +00:00
* @returns {string}
*/
2018-02-14 16:21:52 +00:00
function _getURLFromEvent(event, knownDomains) {
2018-02-14 20:34:33 +00:00
const linkTerminatorPattern = '[^\\s<>$]';
2018-02-08 18:50:19 +00:00
const urlRegExp
2018-04-16 02:04:57 +00:00
= new RegExp(
`http(s)?://(${knownDomains.join('|')})/${linkTerminatorPattern}+`,
'gi');
2018-02-14 20:34:33 +00:00
const schemeRegExp
= new RegExp(`${APP_LINK_SCHEME}${linkTerminatorPattern}+`, 'gi');
2018-02-08 18:50:19 +00:00
const fieldsToSearch = [
event.title,
event.url,
event.location,
event.notes,
event.description
];
for (const field of fieldsToSearch) {
if (typeof field === 'string') {
2018-04-16 02:04:57 +00:00
const matches = urlRegExp.exec(field) || schemeRegExp.exec(field);
if (matches) {
const url = parseURIString(matches[0]);
if (url) {
return url.toString();
}
2018-02-08 18:50:19 +00:00
}
}
}
return null;
}
2018-02-14 16:21:52 +00:00
2018-05-14 15:55:40 +00:00
/**
* Clears the calendar access status when the app comes back from the
* background. This is needed as some users may never quit the app, but puts it
* into the background and we need to try to request for a permission as often
* as possible, but not annoyingly often.
*
* @param {Object} store - The redux store.
* @param {Object} action - The Redux action.
* @private
* @returns {void}
*/
function _maybeClearAccessStatus(store, { appState }) {
appState === 'background'
&& store.dispatch(setCalendarAuthorization(undefined));
}
/**
* Updates the calendar entries in Redux when new list is received.
*
* @param {Object} event - An event returned from the native calendar.
* @param {Array<string>} knownDomains - The known domain list.
2018-04-16 02:04:57 +00:00
* @private
* @returns {CalendarEntry}
*/
function _parseCalendarEntry(event, knownDomains) {
if (event) {
2018-04-16 02:04:57 +00:00
const url = _getURLFromEvent(event, knownDomains);
2018-04-16 02:04:57 +00:00
if (url) {
const startDate = Date.parse(event.startDate);
const endDate = Date.parse(event.endDate);
2018-04-16 02:04:57 +00:00
if (isNaN(startDate) || isNaN(endDate)) {
logger.warn(
'Skipping invalid calendar event',
event.title,
event.startDate,
event.endDate
);
} else {
return {
2018-04-16 02:04:57 +00:00
endDate,
id: event.id,
2018-04-16 02:04:57 +00:00
startDate,
title: event.title,
2018-04-16 02:04:57 +00:00
url
};
}
}
}
return null;
}
/**
* Updates the calendar entries in redux when new list is received. The feature
* calendar-sync doesn't display all calendar events, it displays unique
* title, URL, and start time tuples i.e. it doesn't display subsequent
* occurrences of recurring events, and the repetitions of events coming from
* multiple calendars.
2018-05-14 15:55:40 +00:00
*
* XXX The function's {@code this} is the redux store.
*
* @param {Array<CalendarEntry>} events - The new event list.
2018-04-16 02:04:57 +00:00
* @private
* @returns {void}
*/
2018-05-14 15:55:40 +00:00
function _updateCalendarEntries(events) {
if (!events || !events.length) {
return;
}
// eslint-disable-next-line no-invalid-this
const { dispatch, getState } = this;
const knownDomains = getState()['features/base/known-domains'];
const now = Date.now();
const entryMap = new Map();
for (const event of events) {
const entry = _parseCalendarEntry(event, knownDomains);
if (entry && entry.endDate > now) {
// As was stated above, we don't display subsequent occurrences of
// recurring events, and the repetitions of events coming from
// multiple calendars.
const key = md5.hex(JSON.stringify([
// Obviously, we want to display different conference/meetings
// URLs. URLs are the very reason why we implemented the feature
// calendar-sync in the first place.
entry.url,
// We probably want to display one and the same URL to people if
// they have it under different titles in their Calendar.
// Because maybe they remember the title of the meeting, not the
// URL so they expect to see the title without realizing that
// they have the same URL already under a different title.
entry.title,
// XXX Eventually, given that the URL and the title are the
// same, what sets one event apart from another is the start
// time of the day (note the use of toTimeString() bellow)! The
// day itself is not important because we don't want multiple
// occurrences of a recurring event or repetitions of an even
// from multiple calendars.
new Date(entry.startDate).toTimeString()
]));
const existingEntry = entryMap.get(key);
// We want only the earliest occurrence (which hasn't ended in the
// past, that is) of a recurring event.
if (!existingEntry || existingEntry.startDate > entry.startDate) {
entryMap.set(key, entry);
2018-06-11 12:25:24 +00:00
}
}
}
dispatch(
setCalendarEvents(
Array.from(entryMap.values())
.sort((a, b) => a.startDate - b.startDate)
.slice(0, MAX_LIST_LENGTH)));
}