Added more tests and removed useless functions

screens/Planning/PlanningDisplayScreen.js

 
 import * as React from 'react';
 import {Image, ScrollView, View} from 'react-native';
-import ThemeManager from "../../utils/ThemeManager";
 import HTML from "react-native-render-html";
 import {Linking} from "expo";
 import PlanningEventManager from '../../utils/PlanningEventManager';
 import {Card, withTheme} from 'react-native-paper';
+import DateManager from "../../utils/DateManager";
 
 type Props = {
     navigation: Object,
             <ScrollView style={{paddingLeft: 5, paddingRight: 5}}>
                 <Card.Title
                     title={this.displayData.title}
-                    subtitle={PlanningEventManager.getFormattedTime(this.displayData) + ' | ' + PlanningEventManager.getEventStartDate(this.displayData)}
+                    subtitle={
+                        PlanningEventManager.getFormattedEventTime(this.displayData["date_begin"], this.displayData["date_end"])
+                        + ' | '
+                        + DateManager.getInstance().getTranslatedDate(PlanningEventManager.getDateOnlyString(this.displayData["date_begin"]))}
                 />
                 {this.displayData.logo !== null ?
                     <View style={{width: '100%', height: 300}}>

screens/Planning/PlanningScreen.js

  */
 export default class PlanningScreen extends React.Component<Props, State> {
 
-    agendaRef: Agenda;
+    agendaRef: Object;
     webDataManager: WebDataManager;
 
     lastRefresh: Date;
     generateEmptyCalendar() {
         let end = new Date(new Date().setMonth(new Date().getMonth() + AGENDA_MONTH_SPAN + 1));
         let daysOfYear = {};
-        for (let d = new Date(2019, 8, 1); d <= end; d.setDate(d.getDate() + 1)) {
+        for (let d = new Date(); d <= end; d.setDate(d.getDate() + 1)) {
             daysOfYear[this.getFormattedDate(new Date(d))] = []
         }
         return daysOfYear;
                     <Divider/>
                     <List.Item
                         title={item.title}
-                        description={PlanningEventManager.getFormattedTime(item)}
-                        left={props => <Avatar.Image
+                        description={PlanningEventManager.getFormattedEventTime(item["date_begin"], item["date_end"])}
+                        left={() => <Avatar.Image
                             source={{uri: item.logo}}
                             style={{backgroundColor: 'transparent'}}
                         />}
                     <Divider/>
                     <List.Item
                         title={item.title}
-                        description={PlanningEventManager.getFormattedTime(item)}
+                        description={PlanningEventManager.getFormattedEventTime(item["date_begin"], item["date_end"])}
                         onPress={onPress}
                     />
                 </View>
     generateEventAgenda(eventList: Array<Object>) {
         let agendaItems = this.generateEmptyCalendar();
         for (let i = 0; i < eventList.length; i++) {
-            if (agendaItems[PlanningEventManager.getEventStartDate(eventList[i])] !== undefined) {
-                this.pushEventInOrder(agendaItems, eventList[i], PlanningEventManager.getEventStartDate(eventList[i]));
+            if (PlanningEventManager.getDateOnlyString(eventList[i]["date_begin"]) !== undefined) {
+                this.pushEventInOrder(agendaItems, eventList[i], PlanningEventManager.getDateOnlyString(eventList[i]["date_begin"]));
             }
         }
         this.setState({agendaItems: agendaItems})
             agendaItems[startDate].push(event);
         else {
             for (let i = 0; i < agendaItems[startDate].length; i++) {
-                if (PlanningEventManager.isEventBefore(event, agendaItems[startDate][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) {
         }
     }
 
-    onAgendaRef(ref: Agenda) {
+    onAgendaRef(ref: Object) {
         this.agendaRef = ref;
     }
 

screens/SelfMenuScreen.js

 
 import * as React from 'react';
 import {View} from 'react-native';
-import i18n from "i18n-js";
+import DateManager from "../utils/DateManager";
 import WebSectionList from "../components/WebSectionList";
 import {Card, Text, withTheme} from 'react-native-paper';
 import AprilFoolsManager from "../utils/AprilFoolsManager";
  */
 class SelfMenuScreen extends React.Component<Props> {
 
-    // Hard code strings as toLocaleDateString does not work on current android JS engine
-    daysOfWeek = [];
-    monthsOfYear = [];
-
     getRenderItem: Function;
     getRenderSectionHeader: Function;
     createDataset: Function;
 
     constructor(props) {
         super(props);
-        this.daysOfWeek.push(i18n.t("date.daysOfWeek.monday"));
-        this.daysOfWeek.push(i18n.t("date.daysOfWeek.tuesday"));
-        this.daysOfWeek.push(i18n.t("date.daysOfWeek.wednesday"));
-        this.daysOfWeek.push(i18n.t("date.daysOfWeek.thursday"));
-        this.daysOfWeek.push(i18n.t("date.daysOfWeek.friday"));
-        this.daysOfWeek.push(i18n.t("date.daysOfWeek.saturday"));
-        this.daysOfWeek.push(i18n.t("date.daysOfWeek.sunday"));
-
-        this.monthsOfYear.push(i18n.t("date.monthsOfYear.january"));
-        this.monthsOfYear.push(i18n.t("date.monthsOfYear.february"));
-        this.monthsOfYear.push(i18n.t("date.monthsOfYear.march"));
-        this.monthsOfYear.push(i18n.t("date.monthsOfYear.april"));
-        this.monthsOfYear.push(i18n.t("date.monthsOfYear.may"));
-        this.monthsOfYear.push(i18n.t("date.monthsOfYear.june"));
-        this.monthsOfYear.push(i18n.t("date.monthsOfYear.july"));
-        this.monthsOfYear.push(i18n.t("date.monthsOfYear.august"));
-        this.monthsOfYear.push(i18n.t("date.monthsOfYear.september"));
-        this.monthsOfYear.push(i18n.t("date.monthsOfYear.october"));
-        this.monthsOfYear.push(i18n.t("date.monthsOfYear.november"));
-        this.monthsOfYear.push(i18n.t("date.monthsOfYear.december"));
 
         this.getRenderItem = this.getRenderItem.bind(this);
         this.getRenderSectionHeader = this.getRenderSectionHeader.bind(this);
         for (let i = 0; i < fetchedData.length; i++) {
             result.push(
                 {
-                    title: this.getFormattedDate(fetchedData[i].date),
+                    title: DateManager.getInstance().getTranslatedDate(fetchedData[i].date),
                     data: fetchedData[i].meal[0].foodcategory,
                     extraData: super.state,
                     keyExtractor: this.getKeyExtractor,
         return result
     }
 
-    getFormattedDate(dateString: string) {
-        let dateArray = dateString.split('-');
-        let date = new Date();
-        date.setFullYear(parseInt(dateArray[0]), parseInt(dateArray[1]) - 1, parseInt(dateArray[2]));
-        return this.daysOfWeek[date.getDay() - 1] + " " + date.getDate() + " " + this.monthsOfYear[date.getMonth()] + " " + date.getFullYear();
-    }
-
     getRenderSectionHeader({section}: Object) {
         return (
             <Card style={{

utils/DateManager.js

+import i18n from 'i18n-js';
+
+export default class DateManager {
+    static instance: DateManager | null = null;
+
+    // Hard code strings as toLocaleDateString does not work on current android JS engine
+    daysOfWeek = [];
+    monthsOfYear = [];
+
+    constructor() {
+        this.daysOfWeek.push(i18n.t("date.daysOfWeek.monday"));
+        this.daysOfWeek.push(i18n.t("date.daysOfWeek.tuesday"));
+        this.daysOfWeek.push(i18n.t("date.daysOfWeek.wednesday"));
+        this.daysOfWeek.push(i18n.t("date.daysOfWeek.thursday"));
+        this.daysOfWeek.push(i18n.t("date.daysOfWeek.friday"));
+        this.daysOfWeek.push(i18n.t("date.daysOfWeek.saturday"));
+        this.daysOfWeek.push(i18n.t("date.daysOfWeek.sunday"));
+
+        this.monthsOfYear.push(i18n.t("date.monthsOfYear.january"));
+        this.monthsOfYear.push(i18n.t("date.monthsOfYear.february"));
+        this.monthsOfYear.push(i18n.t("date.monthsOfYear.march"));
+        this.monthsOfYear.push(i18n.t("date.monthsOfYear.april"));
+        this.monthsOfYear.push(i18n.t("date.monthsOfYear.may"));
+        this.monthsOfYear.push(i18n.t("date.monthsOfYear.june"));
+        this.monthsOfYear.push(i18n.t("date.monthsOfYear.july"));
+        this.monthsOfYear.push(i18n.t("date.monthsOfYear.august"));
+        this.monthsOfYear.push(i18n.t("date.monthsOfYear.september"));
+        this.monthsOfYear.push(i18n.t("date.monthsOfYear.october"));
+        this.monthsOfYear.push(i18n.t("date.monthsOfYear.november"));
+        this.monthsOfYear.push(i18n.t("date.monthsOfYear.december"));
+    }
+
+    /**
+     * Get this class instance or create one if none is found
+     * @returns {DateManager}
+     */
+    static getInstance(): DateManager {
+        return DateManager.instance === null ?
+            DateManager.instance = new DateManager() :
+            DateManager.instance;
+    }
+
+    getTranslatedDate(dateString: string) {
+        let dateArray = dateString.split('-');
+        let date = new Date();
+        date.setFullYear(parseInt(dateArray[0]), parseInt(dateArray[1]) - 1, parseInt(dateArray[2]));
+        return this.daysOfWeek[date.getDay() - 1] + " " + date.getDate() + " " + this.monthsOfYear[date.getMonth()] + " " + date.getFullYear();
+    }
+
+}

utils/PlanningEventManager.js

     // Regex used to check date string validity
     static dateRegExp = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/;
 
-    static isEventBefore(event1: Object, event2: Object) {
-        let date1 = new Date();
-        let date2 = new Date();
-        let timeArray = PlanningEventManager.getEventStartTime(event1).split(":");
-        date1.setHours(parseInt(timeArray[0]), parseInt(timeArray[1]));
-        timeArray = PlanningEventManager.getEventStartTime(event2).split(":");
-        date2.setHours(parseInt(timeArray[0]), parseInt(timeArray[1]));
-        return date1 < date2;
-    }
-
-    static getEventStartDate(event: Object) {
-        return event.date_begin.split(" ")[0];
-    }
-
-    static getEventStartTime(event: Object) {
-        if (event !== undefined && Object.keys(event).length > 0 && event.date_begin !== null)
-            return PlanningEventManager.formatTime(event.date_begin.split(" ")[1]);
-        else
-            return "";
-    }
-
-    static getEventEndTime(event: Object) {
-        if (event !== undefined && Object.keys(event).length > 0 && event.date_end !== null)
-            return PlanningEventManager.formatTime(event.date_end.split(" ")[1]);
+    /**
+     * 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
+     * @return {boolean}
+     */
+    static isEventBefore(event1Date: ?string, event2Date: ?string) {
+        let date1 = PlanningEventManager.stringToDate(event1Date);
+        let date2 = PlanningEventManager.stringToDate(event2Date);
+        if (date1 !== undefined && date2 !== undefined)
+            return date1 < date2;
         else
-            return "";
+            return false;
     }
 
-    static getFormattedTime(event: Object) {
-        if (PlanningEventManager.getEventEndTime(event) !== "")
-            return PlanningEventManager.getEventStartTime(event) + " - " + PlanningEventManager.getEventEndTime(event);
+    /**
+     * Gets only the date part of the given event date string in the format
+     * YYYY-MM-DD HH:MM:SS
+     *
+     * @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
+     */
+    static getDateOnlyString(dateString: ?string) {
+        if (PlanningEventManager.isDateStringFormatValid(dateString))
+            return dateString.split(" ")[0];
         else
-            return PlanningEventManager.getEventStartTime(event);
-    }
-
-    static formatTime(time: string) {
-        let array = time.split(':');
-        return array[0] + ':' + array[1];
+            return undefined;
     }
 
     /**
      * Accepted format: YYYY-MM-DD HH:MM:SS
      *
      * @param dateString The string to convert
-     * @return {Date} The date object or undefined 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 | undefined {
         let date = new Date();

utils/__test__/PlanningEventManager.test.js

 test('isDescriptionEmpty', () => {
     expect(PlanningEventManager.isDescriptionEmpty("")).toBeTrue();
     expect(PlanningEventManager.isDescriptionEmpty("   ")).toBeTrue();
+    // noinspection CheckTagEmptyBody
     expect(PlanningEventManager.isDescriptionEmpty("<p></p>")).toBeTrue();
     expect(PlanningEventManager.isDescriptionEmpty("<p>   </p>")).toBeTrue();
     expect(PlanningEventManager.isDescriptionEmpty("<p><br></p>")).toBeTrue();
         .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();
+});
+
+test('isEventBefore', () => {
+    expect(PlanningEventManager.isEventBefore(
+        "2020-03-21 09:00:00", "2020-03-21 10:00:00")).toBeTrue();
+    expect(PlanningEventManager.isEventBefore(
+        "2020-03-21 10:00:00", "2020-03-21 10:15:00")).toBeTrue();
+    expect(PlanningEventManager.isEventBefore(
+        "2020-03-21 10:15:05", "2020-03-21 10:15:54")).toBeTrue();
+    expect(PlanningEventManager.isEventBefore(
+        "2020-03-21 10:15:05", "2021-03-21 10:15:05")).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();
+
+    expect(PlanningEventManager.isEventBefore(
+        "2020-03-21 10:00:00", "2020-03-21 09:00:00")).toBeFalse();
+    expect(PlanningEventManager.isEventBefore(
+        "2020-03-21 10:15:00", "2020-03-21 10:00:00")).toBeFalse();
+    expect(PlanningEventManager.isEventBefore(
+        "2020-03-21 10:15:54", "2020-03-21 10:15:05")).toBeFalse();
+    expect(PlanningEventManager.isEventBefore(
+        "2021-03-21 10:15:05", "2020-03-21 10:15:05")).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();
+
+    expect(PlanningEventManager.isEventBefore(
+        "garbage", "2020-03-21 10:15:05")).toBeFalse();
+    expect(PlanningEventManager.isEventBefore(
+        undefined, undefined)).toBeFalse();
+});
+