Improved JSdoc

removed seconds for new api implementation
Improved flow type checking
2020-03-22 12:15:16 +01:00 · 2020-03-22 11:58:24 +01:00 · 2020-03-22 11:21:55 +01:00 · 2020-03-22 10:37:59 +01:00 · 2020-03-22 10:22:57 +01:00
8 changed files with 202 additions and 244 deletions
--- a/screens/About/DebugScreen.js
+++ b/screens/About/DebugScreen.js
@ -1,9 +1,8 @@
 // @flow

 import * as React from 'react';
-import {Alert, Clipboard, ScrollView, View} from "react-native";
+import {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';

@ -59,23 +58,6 @@ 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
@ -142,15 +124,6 @@ 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'}
--- a/screens/Planning/PlanningScreen.js
+++ b/screens/Planning/PlanningScreen.js
@ -5,6 +5,7 @@ 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";
@ -29,7 +30,6 @@ type State = {
 };

 const FETCH_URL = "https://www.amicale-insat.fr/api/event/list";
-
 const AGENDA_MONTH_SPAN = 3;

 /**
@ -107,20 +107,51 @@ export default class PlanningScreen extends React.Component<Props, State> {
        }
    };

-
-    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))
-                )] = []
-        }
-        return daysOfYear;
+    rowHasChanged(r1: Object, r2: Object) {
+        return false;
+        // if (r1 !== undefined && r2 !== undefined)
+        //     return r1.title !== r2.title;
+        // else return !(r1 === undefined && r2 === undefined);
    }

-    getRenderItem(item: Object) {
+    /**
+     * 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,
+                    });
+                });
+        }
+    };
+
+    onAgendaRef(ref: Object) {
+        this.agendaRef = ref;
+    }
+
+    onCalendarToggled(isCalendarOpened: boolean) {
+        this.setState({calendarShowing: isCalendarOpened});
+    }
+
+    getRenderItem(item: eventObject) {
        const onPress = this.props.navigation.navigate.bind(this, 'PlanningDisplayScreen', {data: item});
        if (item.logo !== null) {
            return (
@ -157,77 +188,6 @@ 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 (
--- a/screens/Tetris/Tetromino.js
+++ b/screens/Tetris/Tetromino.js
@ -1,3 +1,5 @@
+// @flow
+
 export default class Tetromino {

    static types = {
--- a/utils/DateManager.js
+++ b/utils/DateManager.js
@ -1,3 +1,5 @@
+// @flow
+
 import i18n from 'i18n-js';

 export default class DateManager {
--- a/utils/NotificationsManager.js
+++ b/utils/NotificationsManager.js
@ -28,62 +28,6 @@ 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.
@ -105,13 +49,6 @@ 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 !== '') {
--- a/utils/PlanningEventManager.js
+++ b/utils/PlanningEventManager.js
@ -1,7 +1,21 @@
+// @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}:\d{2}$/;
+    static dateRegExp = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/;

    /**
     * Gets the current day string representation in the format
@ -13,17 +27,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:SS
-     * @param event2Date Event 2 date in format YYYY-MM-DD HH:MM:SS
+     * @param event1Date Event 1 date in format YYYY-MM-DD HH:MM
+     * @param event2Date Event 2 date in format YYYY-MM-DD HH:MM
     * @return {boolean}
     */
-    static isEventBefore(event1Date: ?string, event2Date: ?string) {
+    static isEventBefore(event1Date: string, event2Date: string): boolean {
        let date1 = PlanningEventManager.stringToDate(event1Date);
        let date2 = PlanningEventManager.stringToDate(event2Date);
-        if (date1 !== undefined && date2 !== undefined)
+        if (date1 !== null && date2 !== null)
            return date1 < date2;
        else
            return false;
@ -31,26 +45,26 @@ export default class PlanningEventManager {

    /**
     * Gets only the date part of the given event date string in the format
-     * YYYY-MM-DD HH:MM:SS
+     * YYYY-MM-DD HH:MM
     *
     * @param dateString The string to get the date from
-     * @return {string|undefined} Date in format YYYY:MM:DD or undefined if given string is invalid
+     * @return {string|null} Date in format YYYY:MM:DD or null if given string is invalid
     */
-    static getDateOnlyString(dateString: ?string) {
+    static getDateOnlyString(dateString: string): string | null {
        if (PlanningEventManager.isEventDateStringFormatValid(dateString))
            return dateString.split(" ")[0];
        else
-            return undefined;
+            return null;
    }

    /**
     * Checks if the given date string is in the format
-     * YYYY-MM-DD HH:MM:SS
+     * YYYY-MM-DD HH:MM
     *
     * @param dateString The string to check
     * @return {boolean}
     */
-    static isEventDateStringFormatValid(dateString: ?string) {
+    static isEventDateStringFormatValid(dateString: ?string): boolean {
        return dateString !== undefined
            && dateString !== null
            && PlanningEventManager.dateRegExp.test(dateString);
@ -58,12 +72,12 @@ export default class PlanningEventManager {

    /**
     * Converts the given date string to a date object.<br>
-     * Accepted format: YYYY-MM-DD HH:MM:SS
+     * Accepted format: YYYY-MM-DD HH:MM
     *
     * @param dateString The string to convert
-     * @return {Date|undefined} The date object or undefined if the given string is invalid
+     * @return {Date|null} The date object or null if the given string is invalid
     */
-    static stringToDate(dateString: ?string): Date | undefined {
+    static stringToDate(dateString: string): Date | null {
        let date = new Date();
        if (PlanningEventManager.isEventDateStringFormatValid(dateString)) {
            let stringArray = dateString.split(' ');
@ -77,11 +91,11 @@ export default class PlanningEventManager {
            date.setHours(
                parseInt(timeArray[0]),
                parseInt(timeArray[1]),
-                parseInt(timeArray[2]),
+                0,
                0,
            );
        } else
-            date = undefined;
+            date = null;

        return date;
    }
@ -93,14 +107,13 @@ export default class PlanningEventManager {
     * @param date The date object to convert
     * @return {string} The converted string
     */
-    static dateToString(date: Date) {
+    static dateToString(date: Date): string {
        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');
-        const seconds = String(date.getSeconds()).padStart(2, '0');
-        return year + '-' + month + '-' + day + ' ' + hours + ':' + minutes + ':' + seconds;
+        return year + '-' + month + '-' + day + ' ' + hours + ':' + minutes;
    }

    /**
@ -116,12 +129,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 !== undefined && endDate !== undefined && startDate.getTime() !== endDate.getTime()) {
+        if (startDate !== null && endDate !== null && startDate.getTime() !== endDate.getTime()) {
            formattedStr = String(startDate.getHours()).padStart(2, '0') + ':'
                + String(startDate.getMinutes()).padStart(2, '0') + ' - ';
            if (endDate.getFullYear() > startDate.getFullYear()
@ -131,7 +144,7 @@ export default class PlanningEventManager {
            else
                formattedStr += String(endDate.getHours()).padStart(2, '0') + ':'
                    + String(endDate.getMinutes()).padStart(2, '0');
-        } else if (startDate !== undefined)
+        } else if (startDate !== null)
            formattedStr =
                String(startDate.getHours()).padStart(2, '0') + ':'
                + String(startDate.getMinutes()).padStart(2, '0');
@ -157,4 +170,73 @@ 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;
+                }
+            }
+        }
+    }
 }
--- a/utils/WebDataManager.js
+++ b/utils/WebDataManager.js
@ -1,3 +1,4 @@
+// @flow

 /**
 * Class used to get json data from the web
@ -8,7 +9,7 @@ export default class WebDataManager {
    lastDataFetched: Object = {};


-    constructor(url) {
+    constructor(url: string) {
        this.FETCH_URL = url;
    }

--- a/utils/test/PlanningEventManager.test.js
+++ b/utils/test/PlanningEventManager.test.js
@ -18,12 +18,13 @@ test('isDescriptionEmpty', () => {
 });

 test('isEventDateStringFormatValid', () => {
-    expect(PlanningEventManager.isEventDateStringFormatValid("2020-03-21 09:00:00")).toBeTrue();
-    expect(PlanningEventManager.isEventDateStringFormatValid("3214-64-12 01:16:65")).toBeTrue();
+    expect(PlanningEventManager.isEventDateStringFormatValid("2020-03-21 09:00")).toBeTrue();
+    expect(PlanningEventManager.isEventDateStringFormatValid("3214-64-12 01:16")).toBeTrue();

-    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("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("2020-03-21")).toBeFalse();
    expect(PlanningEventManager.isEventDateStringFormatValid("2020-03-21 truc")).toBeFalse();
    expect(PlanningEventManager.isEventDateStringFormatValid("3214-64-12 1:16:65")).toBeFalse();
@ -35,22 +36,22 @@ test('isEventDateStringFormatValid', () => {

 test('stringToDate', () => {
    let testDate = new Date();
-    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();
+    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();
    testDate.setFullYear(2020, 2, 21);
    testDate.setHours(9, 0, 0, 0);
-    expect(PlanningEventManager.stringToDate("2020-03-21 09:00:00")).toEqual(testDate);
+    expect(PlanningEventManager.stringToDate("2020-03-21 09:00")).toEqual(testDate);
    testDate.setFullYear(2020, 0, 31);
-    testDate.setHours(18, 30, 50, 0);
-    expect(PlanningEventManager.stringToDate("2020-01-31 18:30:50")).toEqual(testDate);
+    testDate.setHours(18, 30, 0, 0);
+    expect(PlanningEventManager.stringToDate("2020-01-31 18:30")).toEqual(testDate);
    testDate.setFullYear(2020, 50, 50);
-    testDate.setHours(65, 65, 65, 0);
-    expect(PlanningEventManager.stringToDate("2020-51-50 65:65:65")).toEqual(testDate);
+    testDate.setHours(65, 65, 0, 0);
+    expect(PlanningEventManager.stringToDate("2020-51-50 65:65")).toEqual(testDate);
 });

 test('getFormattedEventTime', () => {
@ -58,58 +59,54 @@ test('getFormattedEventTime', () => {
        .toBe('/ - /');
    expect(PlanningEventManager.getFormattedEventTime(undefined, undefined))
        .toBe('/ - /');
-    expect(PlanningEventManager.getFormattedEventTime("20:30:00", "23:00:00"))
+    expect(PlanningEventManager.getFormattedEventTime("20:30", "23:00"))
        .toBe('/ - /');
    expect(PlanningEventManager.getFormattedEventTime("2020-03-30", "2020-03-31"))
        .toBe('/ - /');


-    expect(PlanningEventManager.getFormattedEventTime("2020-03-21 09:00:00", "2020-03-21 09:00:00"))
+    expect(PlanningEventManager.getFormattedEventTime("2020-03-21 09:00", "2020-03-21 09:00"))
        .toBe('09:00');
-    expect(PlanningEventManager.getFormattedEventTime("2020-03-21 09:00:00", "2020-03-22 17:00:00"))
+    expect(PlanningEventManager.getFormattedEventTime("2020-03-21 09:00", "2020-03-22 17:00"))
        .toBe('09:00 - 23:59');
-    expect(PlanningEventManager.getFormattedEventTime("2020-03-30 20:30:00", "2020-03-30 23:00:00"))
+    expect(PlanningEventManager.getFormattedEventTime("2020-03-30 20:30", "2020-03-30 23:00"))
        .toBe('20:30 - 23:00');
 });

 test('getDateOnlyString', () => {
-    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();
+    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();
 });

 test('isEventBefore', () => {
    expect(PlanningEventManager.isEventBefore(
-        "2020-03-21 09:00:00", "2020-03-21 10:00:00")).toBeTrue();
+        "2020-03-21 09:00", "2020-03-21 10:00")).toBeTrue();
    expect(PlanningEventManager.isEventBefore(
-        "2020-03-21 10:00:00", "2020-03-21 10:15:00")).toBeTrue();
+        "2020-03-21 10:00", "2020-03-21 10:15")).toBeTrue();
    expect(PlanningEventManager.isEventBefore(
-        "2020-03-21 10:15:05", "2020-03-21 10:15:54")).toBeTrue();
+        "2020-03-21 10:15", "2021-03-21 10:15")).toBeTrue();
    expect(PlanningEventManager.isEventBefore(
-        "2020-03-21 10:15:05", "2021-03-21 10:15:05")).toBeTrue();
+        "2020-03-21 10:15", "2020-05-21 10:15")).toBeTrue();
    expect(PlanningEventManager.isEventBefore(
-        "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();
+        "2020-03-21 10:15", "2020-03-30 10:15")).toBeTrue();

    expect(PlanningEventManager.isEventBefore(
-        "2020-03-21 10:00:00", "2020-03-21 09:00:00")).toBeFalse();
+        "2020-03-21 10:00", "2020-03-21 09:00")).toBeFalse();
    expect(PlanningEventManager.isEventBefore(
-        "2020-03-21 10:15:00", "2020-03-21 10:00:00")).toBeFalse();
+        "2020-03-21 10:15", "2020-03-21 10:00")).toBeFalse();
    expect(PlanningEventManager.isEventBefore(
-        "2020-03-21 10:15:54", "2020-03-21 10:15:05")).toBeFalse();
+        "2021-03-21 10:15", "2020-03-21 10:15")).toBeFalse();
    expect(PlanningEventManager.isEventBefore(
-        "2021-03-21 10:15:05", "2020-03-21 10:15:05")).toBeFalse();
+        "2020-05-21 10:15", "2020-03-21 10:15")).toBeFalse();
    expect(PlanningEventManager.isEventBefore(
-        "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();
+        "2020-03-30 10:15", "2020-03-21 10:15")).toBeFalse();

    expect(PlanningEventManager.isEventBefore(
-        "garbage", "2020-03-21 10:15:05")).toBeFalse();
+        "garbage", "2020-03-21 10:15")).toBeFalse();
    expect(PlanningEventManager.isEventBefore(
        undefined, undefined)).toBeFalse();
 });
@ -118,12 +115,16 @@ 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:00");
+    expect(PlanningEventManager.dateToString(testDate)).toBe("2020-03-21 09:00");
    testDate.setFullYear(2021, 0, 12);
    testDate.setHours(9, 10, 0, 0);
-    expect(PlanningEventManager.dateToString(testDate)).toBe("2021-01-12 09:10:00");
+    expect(PlanningEventManager.dateToString(testDate)).toBe("2021-01-12 09:10");
    testDate.setFullYear(2022, 11, 31);
    testDate.setHours(9, 10, 15, 0);
-    expect(PlanningEventManager.dateToString(testDate)).toBe("2022-12-31 09:10:15");
+    expect(PlanningEventManager.dateToString(testDate)).toBe("2022-12-31 09:10");
+});
+
+test('generateEmptyCalendar', () => {
+
 });
Author	SHA1	Message	Date
Arnaud Vergnet	bf0c81166c	Improved JSdoc	2020-03-22 12:15:16 +01:00
Arnaud Vergnet	c6fb369863	removed seconds for new api implementation	2020-03-22 11:58:24 +01:00
Arnaud Vergnet	a6771f442a	Improved flow type checking	2020-03-22 11:21:55 +01:00
Arnaud Vergnet	160dbb00c8	Reorganized code	2020-03-22 10:37:59 +01:00
Arnaud Vergnet	81eddd9bdd	Removed unused functions	2020-03-22 10:22:57 +01:00