screens/About/DebugScreen.js

@@ -1,8 +1,9 @@
 // @flow
 
 import * as React from 'react';
-import {ScrollView, View} from "react-native";
+import {Alert, Clipboard, ScrollView, View} from "react-native";
 import AsyncStorageManager from "../../utils/AsyncStorageManager";
+import NotificationsManager from "../../utils/NotificationsManager";
 import CustomModal from "../../components/CustomModal";
 import {Button, Card, List, Subheading, TextInput, Title, withTheme} from 'react-native-paper';
 
@@ -58,6 +59,23 @@ class DebugScreen extends React.Component<Props, State> {
         }
     }
 
+    alertCurrentExpoToken() {
+        let token = AsyncStorageManager.getInstance().preferences.expoToken.current;
+        Alert.alert(
+            'Expo Token',
+            token,
+            [
+                {text: 'Copy', onPress: () => Clipboard.setString(token)},
+                {text: 'OK'}
+            ]
+        );
+    }
+
+    async forceExpoTokenUpdate() {
+        await NotificationsManager.forceExpoTokenUpdate();
+        this.alertCurrentExpoToken();
+    }
+
     showEditModal(item: Object) {
         this.setState({
             modalCurrentDisplayItem: item
@@ -124,6 +142,15 @@ class DebugScreen extends React.Component<Props, State> {
                     {this.getModalContent()}
                 </CustomModal>
                 <ScrollView style={{padding: 5}}>
+                    <Card style={{margin: 5}}>
+                        <Card.Title
+                            title={'Notifications'}
+                        />
+                        <Card.Content>
+                            {DebugScreen.getGeneralItem(() => this.alertCurrentExpoToken(), 'bell', 'Get current Expo Token', '')}
+                            {DebugScreen.getGeneralItem(() => this.forceExpoTokenUpdate(), 'bell-ring', 'Force Expo token update', '')}
+                        </Card.Content>
+                    </Card>
                     <Card style={{margin: 5}}>
                         <Card.Title
                             title={'Preferences'}

screens/Planning/PlanningScreen.js

@@ -5,7 +5,6 @@ import {BackHandler, View} from 'react-native';
 import i18n from "i18n-js";
 import {LocaleConfig} from 'react-native-calendars';
 import WebDataManager from "../../utils/WebDataManager";
-import type {eventObject} from "../../utils/PlanningEventManager";
 import PlanningEventManager from '../../utils/PlanningEventManager';
 import {Avatar, Divider, List} from 'react-native-paper';
 import CustomAgenda from "../../components/CustomAgenda";
@@ -30,6 +29,7 @@ type State = {
 };
 
 const FETCH_URL = "https://www.amicale-insat.fr/api/event/list";
+
 const AGENDA_MONTH_SPAN = 3;
 
 /**
@@ -107,51 +107,20 @@ export default class PlanningScreen extends React.Component<Props, State> {
         }
     };
 
-    rowHasChanged(r1: Object, r2: Object) {
-        return false;
-        // if (r1 !== undefined && r2 !== undefined)
-        //     return r1.title !== r2.title;
-        // else return !(r1 === undefined && r2 === undefined);
-    }
 
-    /**
-     * Refresh data and show a toast if any error occurred
-     * @private
-     */
-    onRefresh = () => {
-        let canRefresh;
-        if (this.lastRefresh !== undefined)
-            canRefresh = (new Date().getTime() - this.lastRefresh.getTime()) / 1000 > this.minTimeBetweenRefresh;
-        else
-            canRefresh = true;
-
-        if (canRefresh) {
-            this.setState({refreshing: true});
-            this.webDataManager.readData()
-                .then((fetchedData) => {
-                    this.setState({
-                        refreshing: false,
-                        agendaItems: PlanningEventManager.generateEventAgenda(fetchedData, AGENDA_MONTH_SPAN)
-                    });
-                    this.lastRefresh = new Date();
-                })
-                .catch(() => {
-                    this.setState({
-                        refreshing: false,
-                    });
-                });
+    generateEmptyCalendar() {
+        let end = new Date(new Date().setMonth(new Date().getMonth() + AGENDA_MONTH_SPAN + 1));
+        let daysOfYear = {};
+        for (let d = new Date(); d <= end; d.setDate(d.getDate() + 1)) {
+            daysOfYear[
+                PlanningEventManager.getDateOnlyString(
+                    PlanningEventManager.dateToString(new Date(d))
+                )] = []
         }
-    };
-
-    onAgendaRef(ref: Object) {
-        this.agendaRef = ref;
+        return daysOfYear;
     }
 
-    onCalendarToggled(isCalendarOpened: boolean) {
-        this.setState({calendarShowing: isCalendarOpened});
-    }
-
-    getRenderItem(item: eventObject) {
+    getRenderItem(item: Object) {
         const onPress = this.props.navigation.navigate.bind(this, 'PlanningDisplayScreen', {data: item});
         if (item.logo !== null) {
             return (
@@ -188,6 +157,77 @@ export default class PlanningScreen extends React.Component<Props, State> {
         );
     }
 
+    rowHasChanged(r1: Object, r2: Object) {
+        return false;
+        // if (r1 !== undefined && r2 !== undefined)
+        //     return r1.title !== r2.title;
+        // else return !(r1 === undefined && r2 === undefined);
+    }
+
+    /**
+     * Refresh data and show a toast if any error occurred
+     * @private
+     */
+    onRefresh = () => {
+        let canRefresh;
+        if (this.lastRefresh !== undefined)
+            canRefresh = (new Date().getTime() - this.lastRefresh.getTime()) / 1000 > this.minTimeBetweenRefresh;
+        else
+            canRefresh = true;
+
+        if (canRefresh) {
+            this.setState({refreshing: true});
+            this.webDataManager.readData()
+                .then((fetchedData) => {
+                    this.setState({
+                        refreshing: false,
+                    });
+                    this.generateEventAgenda(fetchedData);
+                    this.lastRefresh = new Date();
+                })
+                .catch((err) => {
+                    this.setState({
+                        refreshing: false,
+                    });
+                    // console.log(err);
+                });
+        }
+    };
+
+    generateEventAgenda(eventList: Array<Object>) {
+        let agendaItems = this.generateEmptyCalendar();
+        for (let i = 0; i < eventList.length; i++) {
+            if (PlanningEventManager.getDateOnlyString(eventList[i]["date_begin"]) !== undefined) {
+                this.pushEventInOrder(agendaItems, eventList[i], PlanningEventManager.getDateOnlyString(eventList[i]["date_begin"]));
+            }
+        }
+        this.setState({agendaItems: agendaItems})
+    }
+
+    pushEventInOrder(agendaItems: Object, event: Object, startDate: string) {
+        if (agendaItems[startDate].length === 0)
+            agendaItems[startDate].push(event);
+        else {
+            for (let i = 0; i < agendaItems[startDate].length; i++) {
+                if (PlanningEventManager.isEventBefore(event["date_begin"], agendaItems[startDate][i]["date_begin"])) {
+                    agendaItems[startDate].splice(i, 0, event);
+                    break;
+                } else if (i === agendaItems[startDate].length - 1) {
+                    agendaItems[startDate].push(event);
+                    break;
+                }
+            }
+        }
+    }
+
+    onAgendaRef(ref: Object) {
+        this.agendaRef = ref;
+    }
+
+    onCalendarToggled(isCalendarOpened: boolean) {
+        this.setState({calendarShowing: isCalendarOpened});
+    }
+
     render() {
         // console.log("rendering PlanningScreen");
         return (

screens/Tetris/Tetromino.js

@@ -1,5 +1,3 @@
-// @flow
-
 export default class Tetromino {
 
     static types = {

utils/DateManager.js

@@ -1,5 +1,3 @@
-// @flow
-
 import i18n from 'i18n-js';
 
 export default class DateManager {

utils/NotificationsManager.js

@@ -28,6 +28,62 @@ export default class NotificationsManager {
         return finalStatus === 'granted';
     }
 
+    /**
+     * Async function sending a notification without delay to the user
+     *
+     * @param title {String} Notification title
+     * @param body {String} Notification body text
+     * @returns {Promise<import("react").ReactText>} Notification Id
+     */
+    static async sendNotificationImmediately(title: string, body: string) {
+        await NotificationsManager.askPermissions();
+        return await Notifications.presentLocalNotificationAsync({
+            title: title,
+            body: body,
+        });
+    };
+
+    /**
+     * Async function sending notification at the specified time
+     *
+     * @param title Notification title
+     * @param body Notification body text
+     * @param time Time at which we should send the notification
+     * @param data Data to send with the notification, used for listeners
+     * @param androidChannelID
+     * @returns {Promise<import("react").ReactText>} Notification Id
+     */
+    static async scheduleNotification(title: string, body: string, time: number, data: Object, androidChannelID: string): Promise<string> {
+        await NotificationsManager.askPermissions();
+        let date = new Date();
+        date.setTime(time);
+        return Notifications.scheduleLocalNotificationAsync(
+            {
+                title: title,
+                body: body,
+                data: data,
+                ios: { // configuration for iOS.
+                    sound: true
+                },
+                android: { // configuration for Android.
+                    channelId: androidChannelID,
+                }
+            },
+            {
+                time: time,
+            },
+        );
+    };
+
+    /**
+     * Async function used to cancel the notification of a specific ID
+     * @param notificationID {Number} The notification ID
+     * @returns {Promise}
+     */
+    static async cancelScheduledNotification(notificationID: number) {
+        await Notifications.cancelScheduledNotificationAsync(notificationID);
+    }
+
     /**
      * Save expo token to allow sending notifications to this device.
      * This token is unique for each device and won't change.
@@ -49,6 +105,13 @@ export default class NotificationsManager {
         }
     }
 
+    static async forceExpoTokenUpdate() {
+        await NotificationsManager.askPermissions();
+        let expoToken = await Notifications.getExpoPushTokenAsync();
+        // Save token for instant use later on
+        AsyncStorageManager.getInstance().savePref(AsyncStorageManager.getInstance().preferences.expoToken.key, expoToken);
+    }
+
     static getMachineNotificationWatchlist(callback: Function) {
         let token = AsyncStorageManager.getInstance().preferences.expoToken.current;
         if (token !== '') {

utils/PlanningEventManager.js

@@ -1,21 +1,7 @@
-// @flow
-
-export type eventObject = {
-    id: number,
-    title: string,
-    logo: string,
-    date_begin: string,
-    date_end: string,
-    description: string,
-    club: string,
-    category_id: number,
-    url: string,
-};
-
 export default class PlanningEventManager {
 
     // Regex used to check date string validity
-    static dateRegExp = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/;
+    static dateRegExp = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/;
 
     /**
      * Gets the current day string representation in the format
@@ -27,17 +13,17 @@ export default class PlanningEventManager {
         return PlanningEventManager.dateToString(new Date());
     }
 
-    /**
+     /**
      * Checks if the given date is before the other.
      *
-     * @param event1Date Event 1 date in format YYYY-MM-DD HH:MM
-     * @param event2Date Event 2 date in format YYYY-MM-DD HH:MM
+     * @param event1Date Event 1 date in format YYYY-MM-DD HH:MM:SS
+     * @param event2Date Event 2 date in format YYYY-MM-DD HH:MM:SS
      * @return {boolean}
      */
-    static isEventBefore(event1Date: string, event2Date: string): boolean {
+    static isEventBefore(event1Date: ?string, event2Date: ?string) {
         let date1 = PlanningEventManager.stringToDate(event1Date);
         let date2 = PlanningEventManager.stringToDate(event2Date);
-        if (date1 !== null && date2 !== null)
+        if (date1 !== undefined && date2 !== undefined)
             return date1 < date2;
         else
             return false;
@@ -45,26 +31,26 @@ export default class PlanningEventManager {
 
     /**
      * Gets only the date part of the given event date string in the format
-     * YYYY-MM-DD HH:MM
+     * YYYY-MM-DD HH:MM:SS
      *
      * @param dateString The string to get the date from
-     * @return {string|null} Date in format YYYY:MM:DD or null if given string is invalid
+     * @return {string|undefined} Date in format YYYY:MM:DD or undefined if given string is invalid
      */
-    static getDateOnlyString(dateString: string): string | null {
+    static getDateOnlyString(dateString: ?string) {
         if (PlanningEventManager.isEventDateStringFormatValid(dateString))
             return dateString.split(" ")[0];
         else
-            return null;
+            return undefined;
     }
 
     /**
      * Checks if the given date string is in the format
-     * YYYY-MM-DD HH:MM
+     * YYYY-MM-DD HH:MM:SS
      *
      * @param dateString The string to check
      * @return {boolean}
      */
-    static isEventDateStringFormatValid(dateString: ?string): boolean {
+    static isEventDateStringFormatValid(dateString: ?string) {
         return dateString !== undefined
             && dateString !== null
             && PlanningEventManager.dateRegExp.test(dateString);
@@ -72,12 +58,12 @@ export default class PlanningEventManager {
 
     /**
      * Converts the given date string to a date object.<br>
-     * Accepted format: YYYY-MM-DD HH:MM
+     * Accepted format: YYYY-MM-DD HH:MM:SS
      *
      * @param dateString The string to convert
-     * @return {Date|null} The date object or null if the given string is invalid
+     * @return {Date|undefined} The date object or undefined if the given string is invalid
      */
-    static stringToDate(dateString: string): Date | null {
+    static stringToDate(dateString: ?string): Date | undefined {
         let date = new Date();
         if (PlanningEventManager.isEventDateStringFormatValid(dateString)) {
             let stringArray = dateString.split(' ');
@@ -91,11 +77,11 @@ export default class PlanningEventManager {
             date.setHours(
                 parseInt(timeArray[0]),
                 parseInt(timeArray[1]),
-                0,
+                parseInt(timeArray[2]),
                 0,
             );
         } else
-            date = null;
+            date = undefined;
 
         return date;
     }
@@ -107,13 +93,14 @@ export default class PlanningEventManager {
      * @param date The date object to convert
      * @return {string} The converted string
      */
-    static dateToString(date: Date): string {
+    static dateToString(date: Date) {
         const day = String(date.getDate()).padStart(2, '0');
         const month = String(date.getMonth() + 1).padStart(2, '0'); //January is 0!
         const year = date.getFullYear();
         const hours = String(date.getHours()).padStart(2, '0');
         const minutes = String(date.getMinutes()).padStart(2, '0');
-        return year + '-' + month + '-' + day + ' ' + hours + ':' + minutes;
+        const seconds = String(date.getSeconds()).padStart(2, '0');
+        return year + '-' + month + '-' + day + ' ' + hours + ':' + minutes + ':' + seconds;
     }
 
     /**
@@ -129,12 +116,12 @@ export default class PlanningEventManager {
      * @param end End time in YYYY-MM-DD HH:MM:SS format
      * @return {string} Formatted string or "/ - /" on error
      */
-    static getFormattedEventTime(start: string, end: string): string {
+    static getFormattedEventTime(start: ?string, end: ?string): string {
         let formattedStr = '/ - /';
         let startDate = PlanningEventManager.stringToDate(start);
         let endDate = PlanningEventManager.stringToDate(end);
 
-        if (startDate !== null && endDate !== null && startDate.getTime() !== endDate.getTime()) {
+        if (startDate !== undefined && endDate !== undefined && startDate.getTime() !== endDate.getTime()) {
             formattedStr = String(startDate.getHours()).padStart(2, '0') + ':'
                 + String(startDate.getMinutes()).padStart(2, '0') + ' - ';
             if (endDate.getFullYear() > startDate.getFullYear()
@@ -144,7 +131,7 @@ export default class PlanningEventManager {
             else
                 formattedStr += String(endDate.getHours()).padStart(2, '0') + ':'
                     + String(endDate.getMinutes()).padStart(2, '0');
-        } else if (startDate !== null)
+        } else if (startDate !== undefined)
             formattedStr =
                 String(startDate.getHours()).padStart(2, '0') + ':'
                 + String(startDate.getMinutes()).padStart(2, '0');
@@ -170,73 +157,4 @@ export default class PlanningEventManager {
         } else
             return true;
     }
-
-    /**
-     * Generates an object with an empty array for each key.
-     * Each key is a date string in the format
-     * YYYY-MM-DD
-     *
-     * @param numberOfMonths The number of months to create, starting from the current date
-     * @return {Object}
-     */
-    static generateEmptyCalendar(numberOfMonths: number): Object {
-        const end = new Date(new Date().setMonth(new Date().getMonth() + numberOfMonths + 1));
-        let daysOfYear = {};
-        for (let d = new Date(); d <= end; d.setDate(d.getDate() + 1)) {
-            const dateString = PlanningEventManager.getDateOnlyString(
-                PlanningEventManager.dateToString(new Date(d)));
-            if (dateString !== null)
-                daysOfYear[dateString] = []
-        }
-        return daysOfYear;
-    }
-
-    /**
-     * Generates an object with an array of eventObject at each key.
-     * Each key is a date string in the format
-     * YYYY-MM-DD.
-     *
-     * If no event is available at the given key, the array will be empty
-     *
-     * @param eventList The list of events to map to the agenda
-     * @param numberOfMonths The number of months to create the agenda for
-     * @return {Object}
-     */
-    static generateEventAgenda(eventList: Array<eventObject>, numberOfMonths: number): Object {
-        let agendaItems = PlanningEventManager.generateEmptyCalendar(numberOfMonths);
-        for (let i = 0; i < eventList.length; i++) {
-            const dateString = PlanningEventManager.getDateOnlyString(eventList[i].date_begin);
-            if (dateString !== null) {
-                const eventArray = agendaItems[dateString];
-                if (eventArray !== undefined)
-                    this.pushEventInOrder(eventArray, eventList[i]);
-            }
-
-        }
-        return agendaItems;
-    }
-
-    /**
-     * Adds events to the given array depending on their starting date.
-     *
-     * Events starting before are added at the front.
-     *
-     * @param eventArray The array to hold sorted events
-     * @param event The event to add to the array
-     */
-    static pushEventInOrder(eventArray: Array<eventObject>, event: eventObject): Object {
-        if (eventArray.length === 0)
-            eventArray.push(event);
-        else {
-            for (let i = 0; i < eventArray.length; i++) {
-                if (PlanningEventManager.isEventBefore(event.date_begin, eventArray[i].date_end)) {
-                    eventArray.splice(i, 0, event);
-                    break;
-                } else if (i === eventArray.length - 1) {
-                    eventArray.push(event);
-                    break;
-                }
-            }
-        }
-    }
 }

utils/WebDataManager.js

@@ -1,4 +1,3 @@
-// @flow
 
 /**
  * Class used to get json data from the web
@@ -9,7 +8,7 @@ export default class WebDataManager {
     lastDataFetched: Object = {};
 
 
-    constructor(url: string) {
+    constructor(url) {
         this.FETCH_URL = url;
     }
 

utils/__test__/PlanningEventManager.test.js

@@ -18,13 +18,12 @@ test('isDescriptionEmpty', () => {
 });
 
 test('isEventDateStringFormatValid', () => {
-    expect(PlanningEventManager.isEventDateStringFormatValid("2020-03-21 09:00")).toBeTrue();
-    expect(PlanningEventManager.isEventDateStringFormatValid("3214-64-12 01:16")).toBeTrue();
+    expect(PlanningEventManager.isEventDateStringFormatValid("2020-03-21 09:00:00")).toBeTrue();
+    expect(PlanningEventManager.isEventDateStringFormatValid("3214-64-12 01:16:65")).toBeTrue();
 
-    expect(PlanningEventManager.isEventDateStringFormatValid("3214-64-12 01:16:00")).toBeFalse();
-    expect(PlanningEventManager.isEventDateStringFormatValid("3214-64-12 1:16")).toBeFalse();
-    expect(PlanningEventManager.isEventDateStringFormatValid("3214-f4-12 01:16")).toBeFalse();
-    expect(PlanningEventManager.isEventDateStringFormatValid("sqdd 09:00")).toBeFalse();
+    expect(PlanningEventManager.isEventDateStringFormatValid("3214-64-12 1:16:65")).toBeFalse();
+    expect(PlanningEventManager.isEventDateStringFormatValid("3214-f4-12 01:16:65")).toBeFalse();
+    expect(PlanningEventManager.isEventDateStringFormatValid("sqdd 09:00:00")).toBeFalse();
     expect(PlanningEventManager.isEventDateStringFormatValid("2020-03-21")).toBeFalse();
     expect(PlanningEventManager.isEventDateStringFormatValid("2020-03-21 truc")).toBeFalse();
     expect(PlanningEventManager.isEventDateStringFormatValid("3214-64-12 1:16:65")).toBeFalse();
@@ -36,22 +35,22 @@ test('isEventDateStringFormatValid', () => {
 
 test('stringToDate', () => {
     let testDate = new Date();
-    expect(PlanningEventManager.stringToDate(undefined)).toBeNull();
-    expect(PlanningEventManager.stringToDate("")).toBeNull();
-    expect(PlanningEventManager.stringToDate("garbage")).toBeNull();
-    expect(PlanningEventManager.stringToDate("2020-03-21")).toBeNull();
-    expect(PlanningEventManager.stringToDate("09:00:00")).toBeNull();
-    expect(PlanningEventManager.stringToDate("2020-03-21 09:g0")).toBeNull();
-    expect(PlanningEventManager.stringToDate("2020-03-21 09:g0:")).toBeNull();
+    expect(PlanningEventManager.stringToDate(undefined)).toBeUndefined();
+    expect(PlanningEventManager.stringToDate("")).toBeUndefined();
+    expect(PlanningEventManager.stringToDate("garbage")).toBeUndefined();
+    expect(PlanningEventManager.stringToDate("2020-03-21")).toBeUndefined();
+    expect(PlanningEventManager.stringToDate("09:00:00")).toBeUndefined();
+    expect(PlanningEventManager.stringToDate("2020-03-21 09:g0:00")).toBeUndefined();
+    expect(PlanningEventManager.stringToDate("2020-03-21 09:g0:")).toBeUndefined();
     testDate.setFullYear(2020, 2, 21);
     testDate.setHours(9, 0, 0, 0);
-    expect(PlanningEventManager.stringToDate("2020-03-21 09:00")).toEqual(testDate);
+    expect(PlanningEventManager.stringToDate("2020-03-21 09:00:00")).toEqual(testDate);
     testDate.setFullYear(2020, 0, 31);
-    testDate.setHours(18, 30, 0, 0);
-    expect(PlanningEventManager.stringToDate("2020-01-31 18:30")).toEqual(testDate);
+    testDate.setHours(18, 30, 50, 0);
+    expect(PlanningEventManager.stringToDate("2020-01-31 18:30:50")).toEqual(testDate);
     testDate.setFullYear(2020, 50, 50);
-    testDate.setHours(65, 65, 0, 0);
-    expect(PlanningEventManager.stringToDate("2020-51-50 65:65")).toEqual(testDate);
+    testDate.setHours(65, 65, 65, 0);
+    expect(PlanningEventManager.stringToDate("2020-51-50 65:65:65")).toEqual(testDate);
 });
 
 test('getFormattedEventTime', () => {
@@ -59,54 +58,58 @@ test('getFormattedEventTime', () => {
         .toBe('/ - /');
     expect(PlanningEventManager.getFormattedEventTime(undefined, undefined))
         .toBe('/ - /');
-    expect(PlanningEventManager.getFormattedEventTime("20:30", "23:00"))
+    expect(PlanningEventManager.getFormattedEventTime("20:30:00", "23:00:00"))
         .toBe('/ - /');
     expect(PlanningEventManager.getFormattedEventTime("2020-03-30", "2020-03-31"))
         .toBe('/ - /');
 
 
-    expect(PlanningEventManager.getFormattedEventTime("2020-03-21 09:00", "2020-03-21 09:00"))
+    expect(PlanningEventManager.getFormattedEventTime("2020-03-21 09:00:00", "2020-03-21 09:00:00"))
         .toBe('09:00');
-    expect(PlanningEventManager.getFormattedEventTime("2020-03-21 09:00", "2020-03-22 17:00"))
+    expect(PlanningEventManager.getFormattedEventTime("2020-03-21 09:00:00", "2020-03-22 17:00:00"))
         .toBe('09:00 - 23:59');
-    expect(PlanningEventManager.getFormattedEventTime("2020-03-30 20:30", "2020-03-30 23:00"))
+    expect(PlanningEventManager.getFormattedEventTime("2020-03-30 20:30:00", "2020-03-30 23:00:00"))
         .toBe('20:30 - 23:00');
 });
 
 test('getDateOnlyString', () => {
-    expect(PlanningEventManager.getDateOnlyString("2020-03-21 09:00")).toBe("2020-03-21");
-    expect(PlanningEventManager.getDateOnlyString("2021-12-15 09:00")).toBe("2021-12-15");
-    expect(PlanningEventManager.getDateOnlyString("2021-12-o5 09:00")).toBeNull();
-    expect(PlanningEventManager.getDateOnlyString("2021-12-15 09:")).toBeNull();
-    expect(PlanningEventManager.getDateOnlyString("2021-12-15")).toBeNull();
-    expect(PlanningEventManager.getDateOnlyString("garbage")).toBeNull();
+    expect(PlanningEventManager.getDateOnlyString("2020-03-21 09:00:00")).toBe("2020-03-21");
+    expect(PlanningEventManager.getDateOnlyString("2021-12-15 09:00:00")).toBe("2021-12-15");
+    expect(PlanningEventManager.getDateOnlyString("2021-12-o5 09:00:00")).toBeUndefined();
+    expect(PlanningEventManager.getDateOnlyString("2021-12-15 09:")).toBeUndefined();
+    expect(PlanningEventManager.getDateOnlyString("2021-12-15")).toBeUndefined();
+    expect(PlanningEventManager.getDateOnlyString("garbage")).toBeUndefined();
 });
 
 test('isEventBefore', () => {
     expect(PlanningEventManager.isEventBefore(
-        "2020-03-21 09:00", "2020-03-21 10:00")).toBeTrue();
+        "2020-03-21 09:00:00", "2020-03-21 10:00:00")).toBeTrue();
     expect(PlanningEventManager.isEventBefore(
-        "2020-03-21 10:00", "2020-03-21 10:15")).toBeTrue();
+        "2020-03-21 10:00:00", "2020-03-21 10:15:00")).toBeTrue();
     expect(PlanningEventManager.isEventBefore(
-        "2020-03-21 10:15", "2021-03-21 10:15")).toBeTrue();
+        "2020-03-21 10:15:05", "2020-03-21 10:15:54")).toBeTrue();
     expect(PlanningEventManager.isEventBefore(
-        "2020-03-21 10:15", "2020-05-21 10:15")).toBeTrue();
+        "2020-03-21 10:15:05", "2021-03-21 10:15:05")).toBeTrue();
     expect(PlanningEventManager.isEventBefore(
-        "2020-03-21 10:15", "2020-03-30 10:15")).toBeTrue();
+        "2020-03-21 10:15:05", "2020-05-21 10:15:05")).toBeTrue();
+    expect(PlanningEventManager.isEventBefore(
+        "2020-03-21 10:15:05", "2020-03-30 10:15:05")).toBeTrue();
 
     expect(PlanningEventManager.isEventBefore(
-        "2020-03-21 10:00", "2020-03-21 09:00")).toBeFalse();
+        "2020-03-21 10:00:00", "2020-03-21 09:00:00")).toBeFalse();
     expect(PlanningEventManager.isEventBefore(
-        "2020-03-21 10:15", "2020-03-21 10:00")).toBeFalse();
+        "2020-03-21 10:15:00", "2020-03-21 10:00:00")).toBeFalse();
     expect(PlanningEventManager.isEventBefore(
-        "2021-03-21 10:15", "2020-03-21 10:15")).toBeFalse();
+        "2020-03-21 10:15:54", "2020-03-21 10:15:05")).toBeFalse();
     expect(PlanningEventManager.isEventBefore(
-        "2020-05-21 10:15", "2020-03-21 10:15")).toBeFalse();
+        "2021-03-21 10:15:05", "2020-03-21 10:15:05")).toBeFalse();
     expect(PlanningEventManager.isEventBefore(
-        "2020-03-30 10:15", "2020-03-21 10:15")).toBeFalse();
+        "2020-05-21 10:15:05", "2020-03-21 10:15:05")).toBeFalse();
+    expect(PlanningEventManager.isEventBefore(
+        "2020-03-30 10:15:05", "2020-03-21 10:15:05")).toBeFalse();
 
     expect(PlanningEventManager.isEventBefore(
-        "garbage", "2020-03-21 10:15")).toBeFalse();
+        "garbage", "2020-03-21 10:15:05")).toBeFalse();
     expect(PlanningEventManager.isEventBefore(
         undefined, undefined)).toBeFalse();
 });
@@ -115,16 +118,12 @@ test('dateToString', () => {
     let testDate = new Date();
     testDate.setFullYear(2020, 2, 21);
     testDate.setHours(9, 0, 0, 0);
-    expect(PlanningEventManager.dateToString(testDate)).toBe("2020-03-21 09:00");
+    expect(PlanningEventManager.dateToString(testDate)).toBe("2020-03-21 09:00:00");
     testDate.setFullYear(2021, 0, 12);
     testDate.setHours(9, 10, 0, 0);
-    expect(PlanningEventManager.dateToString(testDate)).toBe("2021-01-12 09:10");
+    expect(PlanningEventManager.dateToString(testDate)).toBe("2021-01-12 09:10:00");
     testDate.setFullYear(2022, 11, 31);
     testDate.setHours(9, 10, 15, 0);
-    expect(PlanningEventManager.dateToString(testDate)).toBe("2022-12-31 09:10");
-});
-
-test('generateEmptyCalendar', () => {
-
+    expect(PlanningEventManager.dateToString(testDate)).toBe("2022-12-31 09:10:15");
 });