screens/Planning/PlanningScreen.js

@@ -59,7 +59,7 @@ export default class PlanningScreen extends React.Component<Props, State> {
     onAgendaRef: Function;
     onCalendarToggled: Function;
     onBackButtonPressAndroid: Function;
-    currentDate = PlanningEventManager.getDateOnlyString(PlanningEventManager.getCurrentDateString());
+    currentDate = this.getCurrentDate();
 
     constructor(props: any) {
         super(props);
@@ -107,15 +107,23 @@ export default class PlanningScreen extends React.Component<Props, State> {
         }
     };
 
+    getCurrentDate() {
+        let today = new Date();
+        return this.getFormattedDate(today);
+    }
+
+    getFormattedDate(date: Date) {
+        let dd = String(date.getDate()).padStart(2, '0');
+        let mm = String(date.getMonth() + 1).padStart(2, '0'); //January is 0!
+        let yyyy = date.getFullYear();
+        return yyyy + '-' + mm + '-' + dd;
+    }
 
     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))
-                )] = []
+            daysOfYear[this.getFormattedDate(new Date(d))] = []
         }
         return daysOfYear;
     }
@@ -194,53 +202,16 @@ export default class PlanningScreen extends React.Component<Props, State> {
         }
     };
 
-    getClonedEventArray(event: Object, times: number) {
-        let cloneArray = [];
-        if (times > 1) {
-            for (let i = 0; i < times; i++) {
-                let clone = JSON.parse(JSON.stringify(event));
-                let startDate = PlanningEventManager.stringToDate(clone["date_begin"]);
-                let endDate = new Date();
-                if (i !== 0) {
-                    startDate.setHours(0, 0, 0);
-                    startDate.setDate(startDate.getDate() + i);
-                    clone["date_begin"] = PlanningEventManager.dateToString(startDate);
-                }
-                if (i !== (times - 1)) {
-                    endDate = PlanningEventManager.stringToDate(clone["date_end"]);
-                    endDate.setHours(23, 59, 0);
-                    endDate.setFullYear(startDate.getFullYear(),
-                        startDate.getMonth(),
-                        startDate.getDate() + i);
-                    clone["date_end"] = PlanningEventManager.dateToString(endDate);
-                }
-                cloneArray.push(clone)
-            }
-        } else
-            cloneArray = [event];
-        return cloneArray;
-    }
-
     generateEventAgenda(eventList: Array<Object>) {
         let agendaItems = this.generateEmptyCalendar();
         for (let i = 0; i < eventList.length; i++) {
             if (PlanningEventManager.getDateOnlyString(eventList[i]["date_begin"]) !== undefined) {
-                const clonedEventArray = this.getClonedEventArray(
-                    eventList[i],
-                    PlanningEventManager.getEventDaysNumber(eventList[i]["date_begin"], eventList[i]["date_end"])
-                );
-                this.pushEvents(agendaItems, clonedEventArray);
+                this.pushEventInOrder(agendaItems, eventList[i], PlanningEventManager.getDateOnlyString(eventList[i]["date_begin"]));
             }
         }
         this.setState({agendaItems: agendaItems})
     }
 
-    pushEvents(agendaItems: Object, eventList: Array<Object>) {
-        for (let i = 0; i < eventList.length; i++) {
-            this.pushEventInOrder(agendaItems, eventList[i], PlanningEventManager.getDateOnlyString(eventList[i]["date_begin"]));
-        }
-    }
-
     pushEventInOrder(agendaItems: Object, event: Object, startDate: string) {
         if (agendaItems[startDate].length === 0)
             agendaItems[startDate].push(event);

utils/DateManager.js

@@ -8,13 +8,13 @@ export default class DateManager {
     monthsOfYear = [];
 
     constructor() {
-        this.daysOfWeek.push(i18n.t("date.daysOfWeek.sunday")); // 0 represents sunday
         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"));
@@ -44,7 +44,7 @@ export default class DateManager {
         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()] + " " + date.getDate() + " " + this.monthsOfYear[date.getMonth()] + " " + date.getFullYear();
+        return this.daysOfWeek[date.getDay() - 1] + " " + date.getDate() + " " + this.monthsOfYear[date.getMonth()] + " " + date.getFullYear();
     }
 
 }

utils/PlanningEventManager.js

@@ -3,40 +3,6 @@ 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}$/;
 
-    /**
-     * Gets the current day string representation in the format
-     * YYYY-MM-DD
-     *
-     * @return {string} The string representation
-     */
-    static getCurrentDateString(): string {
-        return PlanningEventManager.dateToString(new Date());
-    }
-
-    /**
-     * Gets how many days the event lasts. If no end date is specified, defaults to 1.
-     *
-     *
-     * @param start The start date string in format YYYY-MM-DD HH:MM:SS
-     * @param end The end date string in format YYYY-MM-DD HH:MM:SS
-     * @return {number} The number of days, 0 on error
-     */
-    static getEventDaysNumber(start: string, end: string): number {
-        let startDate = PlanningEventManager.stringToDate(start);
-        let endDate = PlanningEventManager.stringToDate(end);
-        if (startDate !== undefined && endDate !== undefined) {
-            if (startDate.getTime() !== endDate.getTime()) {
-                const diffTime = endDate - startDate;
-                return Math.ceil(diffTime / (1000 * 60 * 60 * 24));
-            } else
-                return 1;
-        } else if (startDate !== undefined)
-            return 1;
-        else
-            return 0;
-    }
-
-
     /**
      * Checks if the given date is before the other.
      *
@@ -61,7 +27,7 @@ export default class PlanningEventManager {
      * @return {string|undefined} Date in format YYYY:MM:DD or undefined if given string is invalid
      */
     static getDateOnlyString(dateString: ?string) {
-        if (PlanningEventManager.isEventDateStringFormatValid(dateString))
+        if (PlanningEventManager.isDateStringFormatValid(dateString))
             return dateString.split(" ")[0];
         else
             return undefined;
@@ -74,7 +40,7 @@ export default class PlanningEventManager {
      * @param dateString The string to check
      * @return {boolean}
      */
-    static isEventDateStringFormatValid(dateString: ?string) {
+    static isDateStringFormatValid(dateString: ?string) {
         return dateString !== undefined
             && dateString !== null
             && PlanningEventManager.dateRegExp.test(dateString);
@@ -89,7 +55,7 @@ export default class PlanningEventManager {
      */
     static stringToDate(dateString: ?string): Date | undefined {
         let date = new Date();
-        if (PlanningEventManager.isEventDateStringFormatValid(dateString)) {
+        if (PlanningEventManager.isDateStringFormatValid(dateString)) {
             let stringArray = dateString.split(' ');
             let dateArray = stringArray[0].split('-');
             let timeArray = stringArray[1].split(':');
@@ -111,20 +77,13 @@ export default class PlanningEventManager {
     }
 
     /**
-     * Converts a date object to a string in the format
-     * YYYY-MM-DD HH-MM-SS
+     * Returns a padded string for the given number if it is lower than 10
      *
-     * @param date The date object to convert
-     * @return {string} The converted string
+     * @param i The string to be converted
+     * @return {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');
-        const seconds = String(date.getSeconds()).padStart(2, '0');
-        return year + '-' + month + '-' + day + ' ' + hours + ':' + minutes + ':' + seconds;
+    static toPaddedString(i: number): string {
+        return (i < 10 && i >= 0) ? "0" + i.toString(10) : i.toString(10);
     }
 
     /**
@@ -134,7 +93,7 @@ export default class PlanningEventManager {
      *
      * If the end date is not specified or is equal to start time, only start time will be shown.
      *
-     * If the end date is not on the same day, 23:59 will be shown as end time
+     * If the end date is not on the same day, 00:00 will be shown as end time
      *
      * @param start Start time in YYYY-MM-DD HH:MM:SS format
      * @param end End time in YYYY-MM-DD HH:MM:SS format
@@ -146,19 +105,19 @@ export default class PlanningEventManager {
         let endDate = PlanningEventManager.stringToDate(end);
 
         if (startDate !== undefined && endDate !== undefined && startDate.getTime() !== endDate.getTime()) {
-            formattedStr = String(startDate.getHours()).padStart(2, '0') + ':'
-                + String(startDate.getMinutes()).padStart(2, '0') + ' - ';
+            formattedStr = PlanningEventManager.toPaddedString(startDate.getHours()) + ':'
+                + PlanningEventManager.toPaddedString(startDate.getMinutes()) + ' - ';
             if (endDate.getFullYear() > startDate.getFullYear()
                 || endDate.getMonth() > startDate.getMonth()
                 || endDate.getDate() > startDate.getDate())
-                formattedStr += '23:59';
+                formattedStr += '00:00';
             else
-                formattedStr += String(endDate.getHours()).padStart(2, '0') + ':'
-                    + String(endDate.getMinutes()).padStart(2, '0');
+                formattedStr += PlanningEventManager.toPaddedString(endDate.getHours()) + ':'
+                    + PlanningEventManager.toPaddedString(endDate.getMinutes());
         } else if (startDate !== undefined)
             formattedStr =
-                String(startDate.getHours()).padStart(2, '0') + ':'
-                + String(startDate.getMinutes()).padStart(2, '0');
+                PlanningEventManager.toPaddedString(startDate.getHours()) + ':'
+                + PlanningEventManager.toPaddedString(startDate.getMinutes());
 
         return formattedStr
     }

utils/__test__/PlanningEventManager.test.js

@@ -17,20 +17,30 @@ test('isDescriptionEmpty', () => {
     expect(PlanningEventManager.isDescriptionEmpty("<p>coucou</p>")).toBeFalse();
 });
 
-test('isEventDateStringFormatValid', () => {
-    expect(PlanningEventManager.isEventDateStringFormatValid("2020-03-21 09:00:00")).toBeTrue();
-    expect(PlanningEventManager.isEventDateStringFormatValid("3214-64-12 01:16:65")).toBeTrue();
+test('toPaddedString', () => {
+    expect(PlanningEventManager.toPaddedString(-1)).toBe("-1");
+    expect(PlanningEventManager.toPaddedString(0)).toBe("00");
+    expect(PlanningEventManager.toPaddedString(1)).toBe("01");
+    expect(PlanningEventManager.toPaddedString(2)).toBe("02");
+    expect(PlanningEventManager.toPaddedString(10)).toBe("10");
+    expect(PlanningEventManager.toPaddedString(53)).toBe("53");
+    expect(PlanningEventManager.toPaddedString(100)).toBe("100");
+});
 
-    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();
-    expect(PlanningEventManager.isEventDateStringFormatValid("garbage")).toBeFalse();
-    expect(PlanningEventManager.isEventDateStringFormatValid("")).toBeFalse();
-    expect(PlanningEventManager.isEventDateStringFormatValid(undefined)).toBeFalse();
-    expect(PlanningEventManager.isEventDateStringFormatValid(null)).toBeFalse();
+test('isDateStringFormatValid', () => {
+    expect(PlanningEventManager.isDateStringFormatValid("2020-03-21 09:00:00")).toBeTrue();
+    expect(PlanningEventManager.isDateStringFormatValid("3214-64-12 01:16:65")).toBeTrue();
+
+    expect(PlanningEventManager.isDateStringFormatValid("3214-64-12 1:16:65")).toBeFalse();
+    expect(PlanningEventManager.isDateStringFormatValid("3214-f4-12 01:16:65")).toBeFalse();
+    expect(PlanningEventManager.isDateStringFormatValid("sqdd 09:00:00")).toBeFalse();
+    expect(PlanningEventManager.isDateStringFormatValid("2020-03-21")).toBeFalse();
+    expect(PlanningEventManager.isDateStringFormatValid("2020-03-21 truc")).toBeFalse();
+    expect(PlanningEventManager.isDateStringFormatValid("3214-64-12 1:16:65")).toBeFalse();
+    expect(PlanningEventManager.isDateStringFormatValid("garbage")).toBeFalse();
+    expect(PlanningEventManager.isDateStringFormatValid("")).toBeFalse();
+    expect(PlanningEventManager.isDateStringFormatValid(undefined)).toBeFalse();
+    expect(PlanningEventManager.isDateStringFormatValid(null)).toBeFalse();
 });
 
 test('stringToDate', () => {
@@ -67,7 +77,7 @@ test('getFormattedEventTime', () => {
     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:00", "2020-03-22 17:00:00"))
-        .toBe('09:00 - 23:59');
+        .toBe('09:00 - 00:00');
     expect(PlanningEventManager.getFormattedEventTime("2020-03-30 20:30:00", "2020-03-30 23:00:00"))
         .toBe('20:30 - 23:00');
 });
@@ -114,24 +124,3 @@ test('isEventBefore', () => {
         undefined, undefined)).toBeFalse();
 });
 
-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");
-    testDate.setFullYear(2021, 0, 12);
-    testDate.setHours(9, 10, 0, 0);
-    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:15");
-});
-
-test('getEventDaysNumber', () => {
-    expect(PlanningEventManager.getEventDaysNumber('2020-03-21 09:00:00', '2020-03-22 17:00:00')).toBe(2);
-    expect(PlanningEventManager.getEventDaysNumber('2020-03-21 09:00:00', '2020-03-21 17:00:00')).toBe(1);
-    expect(PlanningEventManager.getEventDaysNumber('2020-03-21 09:00:00', '2020-03-21 09:00:00')).toBe(1);
-    expect(PlanningEventManager.getEventDaysNumber('2020-03-21 09:gg:00', '2020-03-21 17:00:00')).toBe(0);
-    expect(PlanningEventManager.getEventDaysNumber('2020-03-21 09:00:00', undefined)).toBe(1);
-    expect(PlanningEventManager.getEventDaysNumber('2020-03-21 09:00:00', '2020-04-05 20:00:00')).toBe(16);
-});