@colijnit/sharedcomponents 1.0.55 → 1.0.56

package/projects/sharedcomponents/src/lib/utils/date-utils.ts

@@ -0,0 +1,302 @@
+import {Month} from "../enum/month.enum";
+import {ALL_MONTHS} from "../model/constant/all-months";
+import {notNill} from "./function/not-nill.function";
+import * as moment from "moment";
+import {Moment} from "moment";
+import {DatePipe} from "@angular/common";
+import {DateRange} from "../model/date-range";
+
+Date.prototype.toJSON = function() {
+    return moment(this).format('YYYY-MM-DD[T]HH:mm:ss');
+}
+
+// static utility function holder related to dates
+export class DateUtils {
+    public static readonly BACKEND_DATE_FORMAT: string = 'YYYY-MM-DD[T]HH:mm:ss';
+    public static datePipe: DatePipe = new DatePipe('shortDate');
+
+    public static NowAsString(): string {
+        return DateUtils.ParseDate(new Date(), DateUtils.BACKEND_DATE_FORMAT);
+    }
+
+    public static ParseDate(date: Date, format: string = "d-m-y"): string {
+        if (!date) {
+            return "";
+        }
+
+        const day: string = ("0" + date.getDate()).slice(-2);
+        const month: string = ("0" + (date.getMonth() + 1)).slice(-2);
+        const year: string = date.getFullYear() + "";
+
+        const formatParts: string[] = format.split("-");
+        const dateParts: string[] = [];
+
+
+        for (let i: number = 0, l: number = formatParts.length; i < l; i++) {
+            switch (formatParts[i]) {
+                case "d" :
+                case "DD" :
+                    dateParts.push(day);
+                    break;
+                case "m" :
+                case "MM" :
+                    dateParts.push(month);
+                    break;
+                case "y" :
+                case "YYYY" :
+                    dateParts.push(year);
+                    break;
+                default:
+                    break;
+            }
+        }
+        return dateParts.join("-");
+    }
+
+    public static GetWeekNumber(date: Date): number {
+        date = new Date(date.getTime());
+        date.setHours(0, 0, 0, 0);
+        date.setDate(date.getDate() + 4 - (date.getDay() || 7));
+        return Math.ceil((((date.getTime() - new Date(date.getFullYear(), 0, 1).getTime()) / 8.64e7) + 1) / 7);
+    }
+
+    // Returns the number of days from now, for the given date in the future. Returns negative days if given date is in the past from now.
+    public static GetDaysFromNow(date: Date): number {
+        return DateUtils.GetDayDifference(new Date(Date.now()), date);
+    }
+
+    public static StringAsDate(str: string, format: string = DateUtils.BACKEND_DATE_FORMAT): Date {
+        if (notNill(str)) {
+            if (!isNaN(Number(str))) {
+                return new Date(str);
+            } else {
+                const time: any = moment(str, format, true);
+                return time.isValid() ? new Date(time) : undefined;
+            }
+        } else {
+            return undefined;
+        }
+    }
+
+    public static MomentToDate(time: Moment): Date {
+        if (!time || !time.isValid()) {
+            return undefined;
+        }
+
+        const d: Date = new Date(time.format(DateUtils.BACKEND_DATE_FORMAT));
+        d.setHours(time.hours());
+        d.setMinutes(time.minutes());
+        d.setSeconds(time.seconds());
+        return d;
+    }
+
+    public static GetCurrentMonth(): Month {
+        return ALL_MONTHS[new Date().getMonth()];
+    }
+
+    // @returns e.g. ["FEBRUARI", "MARCH", ..] if it's Februari today, otherwise e.g. ["APRIL", "MAY", ...] if it's April today
+    public static Get12MonthsArrayWithFirstMonthIsCurrentMonth(): Month[] {
+        const answer: Month[] = [];
+
+        let monthNrToAdd: number = new Date().getMonth();
+        for (let i: number = 0; i < 12; i++) {
+            answer.push(ALL_MONTHS[monthNrToAdd]);
+            monthNrToAdd = (monthNrToAdd + 1) % ALL_MONTHS.length;
+        }
+
+        return answer;
+    }
+
+    public static GetFirstDayOfWeek(date: Date): Date {
+        if (!DateUtils._ValidDate(date)) {
+            return null;
+        }
+        let firstDay: Date;
+        const dayOfWeek: number = date.getDay() || 7;
+        if (dayOfWeek === 1) {
+            firstDay = new Date(date);
+        } else {
+            firstDay = new Date(date);
+            firstDay.setHours(-24 * (dayOfWeek - 1));
+        }
+        return firstDay;
+    }
+
+    public static GetLastDayOfWeek(date: Date): Date {
+        const firstDayOfWeek: Date = DateUtils.GetFirstDayOfWeek(date);
+        const lastDayOfWeek: Date = new Date(firstDayOfWeek);
+        lastDayOfWeek.setDate(firstDayOfWeek.getDate() + 6);
+        return lastDayOfWeek;
+    }
+
+    public static GetFirstDayOfMonth(date: Date): Date {
+        if (!DateUtils._ValidDate(date)) {
+            return null;
+        }
+        const year: number = date.getFullYear();
+        const month: number = date.getMonth();
+        return new Date(year, month, 1);
+    }
+
+    public static GetLastDayOfMonth(date: Date): Date {
+        if (!DateUtils._ValidDate(date)) {
+            return null;
+        }
+        const year: number = date.getFullYear();
+        const month: number = date.getMonth();
+        return new Date(year, month + 1, 0);
+    }
+
+    public static DatesEqual(date1: Date, date2: Date): boolean {
+        let result: boolean = false;
+        if (DateUtils._ValidDate(date1) && DateUtils._ValidDate(date2)) {
+            result =
+                date1.getDate() === date2.getDate() &&
+                date1.getMonth() === date2.getMonth() &&
+                date1.getFullYear() === date2.getFullYear();
+        }
+        return result;
+    }
+
+    public static DateRangeEqual(dates1: DateRange, dates2: DateRange): boolean {
+        return (this.DatesEqual(dates1.startDate, dates2.startDate) &&
+            this.DatesEqual(dates1.endDate, dates2.endDate));
+    }
+
+    public static AddMinutes(date: Date, minutes: number): Date {
+        return new Date(date.getTime() + (minutes * 60000));
+    }
+
+    public static AddDays(date: Date, days: number): Date {
+        const result: Date = new Date(date);
+        result.setDate(result.getDate() + days);
+        return result;
+    }
+
+    public static AddMonths(date: Date, months: number): Date {
+        const result: Date = new Date(date);
+        result.setMonth(result.getMonth() + months);
+        return result;
+    }
+
+    public static DetermineDSTBreakpoints(): { start: string, end: string } {
+        const endOfYear: Date = new Date(new Date().getFullYear(), 11, 1);
+        let checkDate: Date = new Date(new Date().getFullYear(), 0, 1);
+        let offset: number = checkDate.getTimezoneOffset();
+
+        const periodStart: Date = new Date();
+        let periodStartSet: boolean = false;
+        const periodEnd: Date = new Date();
+        let periodEndSet: boolean = false;
+        while (checkDate.getTime() < endOfYear.getTime()) {
+            checkDate = this.AddMinutes(checkDate, 60);
+            if (offset < checkDate.getTimezoneOffset()) {
+                periodEnd.setTime(checkDate.getTime());
+                periodEndSet = true;
+            } else if (offset > checkDate.getTimezoneOffset()) {
+                periodStart.setTime(checkDate.getTime());
+                periodStartSet = true;
+            }
+            offset = checkDate.getTimezoneOffset();
+            if (periodStartSet && periodEndSet) {
+                break;
+            }
+        }
+
+        if (periodStartSet && periodEndSet) {
+            return {
+                start: this._DateToTimeStringWithDateFormat(periodStart),
+                end: this._DateToTimeStringWithDateFormat(periodEnd)
+            };
+        } else {
+            return {start: undefined, end: undefined}; // important otherwise we return new Date() for both
+        }
+    }
+
+    private static _ValidDate(date: Date): boolean {
+        return date !== null && date !== undefined;
+    }
+
+    /**
+     * Returns the difference between the two given days as the number of days, in float precision (date to - date from).
+     * Returns negative values of the 'from' date is later than in time than the 'to' date.
+     */
+    public static GetDayDifference(from: Date, to: Date): number {
+        if (!from || !to) {
+            return NaN;
+        }
+        return ((to.getTime() - from.getTime()) / 1000 / 60 / 60 / 24);
+    }
+
+    public static IsSameDay(dateOne: Date, dateTwo: Date): boolean {
+        return (dateOne && dateTwo &&
+            dateOne.getDate() === dateTwo.getDate()
+            && dateOne.getMonth() === dateTwo.getMonth()
+            && dateOne.getFullYear() === dateTwo.getFullYear());
+    }
+
+    public static IsInBetween(date: Date, startDate: Date, endDate: Date, withTime: boolean = true): boolean {
+        if (startDate && endDate) {
+            if (withTime) {
+                return (date > startDate && date < endDate);
+            } else {
+                const dateWithoutTime: number = new Date(date).setHours(0, 0, 0, 0),
+                    dateFromWithoutTime: number = new Date(startDate).setHours(0, 0, 0, 0),
+                    dateToWithoutTime: number = new Date(endDate).setHours(0, 0, 0, 0);
+                return dateWithoutTime >= dateFromWithoutTime && dateWithoutTime <= dateToWithoutTime;
+            }
+        }
+    }
+
+    public static IsMonday(date: Date): boolean {
+        return date.getDay() === 1;
+    }
+
+    public static IsSunday(date: Date): boolean {
+        return date.getDay() === 0;
+    }
+
+    public static IsToday(date: Date): boolean {
+        const today: Date = new Date();
+        return DateUtils.IsSameDay(today, date);
+    }
+
+    // Returns date format like it would when using a pipe in the templete, ie: "1 okt. 2020"
+    public static ParseDateInShortDateFormat(date: Date, locale: string): string {
+        this.datePipe = new DatePipe(locale);
+        const parsedDate: string = this.datePipe.transform(date);
+        return parsedDate;
+    }
+
+    // Transforms a string that is formatted like "'17-08-2014'<=?<='17-08-2021'" into "'17-08-2014' Untill '17-08-2021'"
+    public static getFormattedDateRangeString(dateRangeString: string, separator: string = " - "): string {
+        let newString: string = dateRangeString;
+        newString = newString.replace("<=?<=", ` ${separator} `);
+        newString = newString.replace(/'/g, "");
+
+        return newString;
+    }
+
+    public static SetDateOrDateRangeObjectHoursZero(date: Date | DateRange): void {
+        if (date instanceof DateRange) {
+            if (date.startDate) {
+                date.startDate.setHours(0, 0, 0);
+            }
+            if (date.endDate) {
+                date.endDate.setHours(0, 0, 0);
+            }
+        } else if (!!date && (date instanceof Date)) {
+            date.setHours(0, 0, 0, 0);
+        }
+    }
+
+    private static _DateToTimeStringWithDateFormat(value: Date, dateFormat: string = "d-m-y"): string {
+        if (!value) {
+            return "";
+        }
+
+        const hours: string = value.getHours() < 10 ? "0" + value.getHours() : "" + value.getHours();
+        const minutes: string = value.getMinutes() < 10 ? "0" + value.getMinutes() : "" + value.getMinutes();
+        return this.ParseDate(value, dateFormat) + " " + [hours, minutes].join(":");
+    }
+}

package/projects/sharedcomponents/src/lib/utils/function/not-nill.function.ts

@@ -0,0 +1,4 @@
+// @returns true iff given value does not equals null and does not equal undefined
+export function notNill(value: any): boolean {
+    return value !== null && value !== undefined;
+}

package/projects/sharedcomponents/src/lib/utils/is-nill.function.ts

@@ -0,0 +1,4 @@
+// @returns true iff given value equals null or equals undefined
+export function isNill(value: any): boolean {
+    return value === null || value === undefined;
+}

package/projects/sharedcomponents/src/lib/utils/map-utils.ts

@@ -0,0 +1,44 @@
+// Static utility functions holder related to Maps.
+export class MapUtils {
+
+    /**
+     * Returns the first key from given map, for which the value filter holds true. Basically a reverse Map.get(key) function.
+     * @param map
+     * @param valueFilter For the first value that returns true for this filter functions, its key will be returned.
+     */
+    public static FindKeyByValue<K, V>(map: Map<K, V>, valueFilter: (value: V) => boolean): K {
+
+        if (!map || !valueFilter) {
+            return undefined;
+        }
+
+        let foundKey: K = undefined;
+        let keyWasFound: boolean = false;
+        map.forEach((value: V, key: K) => {
+            if (!keyWasFound && valueFilter.call(this, value)) {
+                foundKey = key;
+                keyWasFound = true;
+            }
+        });
+        return foundKey;
+    }
+
+    /**
+     * Inserts given arrayEntry into given map, under given mapKey. What's special here, is that a NEW map entry is created with an array
+     * containing the single [arrayEntry] item, if no entry yet existed.
+     * @param map
+     * @param mapKey
+     * @param arrayEntry
+     */
+    public static InsertArrayItemIntoMap(map: Map<any, any>, mapKey: any, arrayEntry: any): void {
+        if (!map) {
+            return;
+        }
+
+        if (!map.has(mapKey)) {
+            map.set(mapKey, [arrayEntry]);
+        } else {
+            map.get(mapKey).push(arrayEntry);
+        }
+    }
+}